v2: 17 out of 26 builtin tests now pass with cleanc

Author: medvednikov

vlib/builtin/map_notd_gcboehm_opt.v

@@ -0,0 +1,35 @@
+// dummy placeholder for functions from `map_d_gcboehm_opt.v`
+// that might be needed for compile time
+// `$if gcboehm_opt ? { ... } $else { ... }`
+
+module builtin
+
+fn new_map_noscan_key(key_bytes int, value_bytes int, hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn,
+	free_fn MapFreeFn) map {
+	return new_map(key_bytes, value_bytes, hash_fn, key_eq_fn, clone_fn, free_fn)
+}
+
+fn new_map_noscan_value(key_bytes int, value_bytes int, hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn,
+	free_fn MapFreeFn) map {
+	return new_map(key_bytes, value_bytes, hash_fn, key_eq_fn, clone_fn, free_fn)
+}
+
+fn new_map_noscan_key_value(key_bytes int, value_bytes int, hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn,
+	free_fn MapFreeFn) map {
+	return new_map(key_bytes, value_bytes, hash_fn, key_eq_fn, clone_fn, free_fn)
+}
+
+fn new_map_init_noscan_key(hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn, free_fn MapFreeFn,
+	n int, key_bytes int, value_bytes int, keys voidptr, values voidptr) map {
+	return new_map_init(hash_fn, key_eq_fn, clone_fn, free_fn, n, key_bytes, value_bytes, keys, values)
+}
+
+fn new_map_init_noscan_value(hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn, free_fn MapFreeFn,
+	n int, key_bytes int, value_bytes int, keys voidptr, values voidptr) map {
+	return new_map_init(hash_fn, key_eq_fn, clone_fn, free_fn, n, key_bytes, value_bytes, keys, values)
+}
+
+fn new_map_init_noscan_key_value(hash_fn MapHashFn, key_eq_fn MapEqFn, clone_fn MapCloneFn, free_fn MapFreeFn,
+	n int, key_bytes int, value_bytes int, keys voidptr, values voidptr) map {
+	return new_map_init(hash_fn, key_eq_fn, clone_fn, free_fn, n, key_bytes, value_bytes, keys, values)
+}

vlib/v2/gen/cleanc/cleancnew.v

@@ -455,6 +455,8 @@ pub fn (mut g Gen) gen() string {
 	g.sb.writeln('')
 
 	// Pass 4: Function forward declarations
+	mut test_fn_names := []string{}
+	mut has_main := false
 	for file in g.files {
 		g.set_file_module(file)
 		for stmt in file.stmts {
@@ -473,6 +475,13 @@ pub fn (mut g Gen) gen() string {
 				if fn_name == '' {
 					continue
 				}
+				if fn_name == 'main' {
+					has_main = true
+				}
+				if stmt.name.starts_with('test_') && !stmt.is_method
+					&& stmt.typ.params.len == 0 {
+					test_fn_names << fn_name
+				}
 				if g.env != unsafe { nil } {
 					if fn_scope := g.env.get_fn_scope(g.cur_module, fn_name) {
 						g.cur_fn_scope = fn_scope
@@ -494,6 +503,25 @@ pub fn (mut g Gen) gen() string {
 		g.gen_file(file)
 	}
 
+	// Generate test runner main if this is a test file (has test_ functions but no main)
+	if !has_main && test_fn_names.len > 0 {
+		g.sb.writeln('')
+		g.sb.writeln('int main(int ___argc, char** ___argv) {')
+		g.sb.writeln('\tg_main_argc = ___argc;')
+		g.sb.writeln('\tg_main_argv = (void*)___argv;')
+		for test_fn in test_fn_names {
+			msg_run := 'Running test: ${test_fn}...'
+			msg_ok := '  OK'
+			g.sb.writeln('\tprintln((string){"${msg_run}", sizeof("${msg_run}") - 1});')
+			g.sb.writeln('\t${test_fn}();')
+			g.sb.writeln('\tprintln((string){"${msg_ok}", sizeof("${msg_ok}") - 1});')
+		}
+		msg_all := 'All ${test_fn_names.len} tests passed.'
+		g.sb.writeln('\tprintln((string){"${msg_all}", sizeof("${msg_all}") - 1});')
+		g.sb.writeln('\treturn 0;')
+		g.sb.writeln('}')
+	}
+
 	return g.sb.str()
 }
 
@@ -1302,9 +1330,19 @@ fn (mut g Gen) gen_stmt(node ast.Stmt) {
 		ast.ExprStmt {
 			if node.expr is ast.UnsafeExpr {
 				unsafe_expr := node.expr as ast.UnsafeExpr
+				if unsafe_expr.stmts.len > 1 {
+					g.write_indent()
+					g.sb.writeln('{')
+					g.indent++
+				}
 				for stmt in unsafe_expr.stmts {
 					g.gen_stmt(stmt)
 				}
+				if unsafe_expr.stmts.len > 1 {
+					g.indent--
+					g.write_indent()
+					g.sb.writeln('}')
+				}
 				return
 			}
 			if node.expr is ast.IfExpr {
@@ -3452,6 +3490,12 @@ fn escape_c_string_literal_content(raw string) string {
 		if ch == `"` {
 			sb.write_u8(`\\`)
 			sb.write_u8(`"`)
+		} else if ch == `\n` {
+			sb.write_u8(`\\`)
+			sb.write_u8(`n`)
+		} else if ch == `\r` {
+			sb.write_u8(`\\`)
+			sb.write_u8(`r`)
 		} else {
 			sb.write_u8(ch)
 		}
@@ -3662,10 +3706,20 @@ fn (mut g Gen) gen_expr(node ast.Expr) {
 				g.sb.write_string('false')
 			} else if node.kind == .char {
 				raw := strip_literal_quotes(node.value)
-				escaped := escape_char_literal_content(raw)
-				g.sb.write_u8(`'`)
-				g.sb.write_string(escaped)
-				g.sb.write_u8(`'`)
+				if raw.len > 1 && raw[0] != `\\` {
+					// Multi-byte UTF-8 character: emit as numeric codepoint
+					runes := raw.runes()
+					if runes.len > 0 {
+						g.sb.write_string(int(runes[0]).str())
+					} else {
+						g.sb.write_string("'${raw}'")
+					}
+				} else {
+					escaped := escape_char_literal_content(raw)
+					g.sb.write_u8(`'`)
+					g.sb.write_string(escaped)
+					g.sb.write_u8(`'`)
+				}
 			} else {
 				g.sb.write_string(sanitize_c_number_literal(node.value))
 			}
@@ -4427,6 +4481,12 @@ fn (mut g Gen) gen_expr(node ast.Expr) {
 			}
 		}
 		ast.SelectorExpr {
+			// typeof(x).name -> just emit the typeof string directly (already a string)
+			if node.lhs is ast.KeywordOperator && node.lhs.op == .key_typeof
+				&& node.rhs.name == 'name' {
+				g.gen_keyword_operator(node.lhs)
+				return
+			}
 			// C.<ident> references C macros/constants directly (e.g. C.EOF -> EOF).
 			if node.lhs is ast.Ident && node.lhs.name == 'C' {
 				g.sb.write_string(node.rhs.name)

vlib/v2/pref/pref.v

@@ -69,14 +69,14 @@ fn detect_vroot() string {
 
 pub fn new_preferences() Preferences {
 	return Preferences{
-		backend: if os.user_os() == 'macos' { .arm64 } else { .x64 }
+		backend: .cleanc
 	}
 }
 
 // new_preferences_from_args parses full args list including option values
 pub fn new_preferences_from_args(args []string) Preferences {
-	// Default backend based on OS: macOS defaults to arm64, others to x64
-	default_backend := if os.user_os() == 'macos' { 'arm64' } else { 'x64' }
+	// Default backend is cleanc
+	default_backend := 'cleanc'
 	mut backend_str_long := cmdline.option(args, '-backend', '')
 	if backend_str_long.len == 0 {
 		backend_str_long = ''
@@ -92,7 +92,7 @@ pub fn new_preferences_from_args(args []string) Preferences {
 	} else {
 		default_backend
 	}
-	mut backend := if os.user_os() == 'macos' { Backend.arm64 } else { Backend.x64 }
+	mut backend := Backend.cleanc
 	match backend_str {
 		'cleanc' { backend = .cleanc }
 		'v' { backend = .v }

vlib/v2/scanner/scanner.v

@@ -557,7 +557,7 @@ fn (mut s Scanner) number() {
 			s.offset++
 			for {
 				c2 := s.src[s.offset]
-				if c2 >= `0` && c2 <= `7` {
+				if (c2 >= `0` && c2 <= `7`) || c2 == `_` {
 					s.offset++
 					continue
 				}
@@ -575,8 +575,9 @@ fn (mut s Scanner) number() {
 			s.offset++
 			continue
 		}
-		// fraction
-		else if !has_decimal && c == `.` && s.src[s.offset + 1] != `.` {
+		// fraction (only if next char after '.' is a digit, not a letter like '.hex()')
+		else if !has_decimal && c == `.` && s.src[s.offset + 1] != `.`
+			&& s.src[s.offset + 1] >= `0` && s.src[s.offset + 1] <= `9` {
 			has_decimal = true
 			s.offset++
 			continue

vlib/v2/ssa/builder.v

@@ -3489,6 +3489,14 @@ fn (mut b Builder) expr_call(node ast.CallExpr) ValueID {
 						mangled_type = base_type
 					}
 					name = '${mangled_type}__${mangled_method}'
+					// If method not found, try lowercase type name (e.g., Array -> array)
+					if !map_has_key_type_id(b.func_ret_types, name) {
+						lower_name := '${mangled_type.to_lower()}__${mangled_method}'
+						if map_has_key_type_id(b.func_ret_types, lower_name) {
+							name = lower_name
+							mangled_type = mangled_type.to_lower()
+						}
+					}
 					is_method_call = true
 					// Check if this is a flag enum method
 					if map_has_key_bool(b.flag_enum_names, mangled_type)
@@ -3786,7 +3794,7 @@ fn (mut b Builder) expr_call_or_cast(node ast.CallOrCastExpr) ValueID {
 	if node.lhs is ast.Ident {
 		cast_name := node.lhs.name
 		if cast_name in ['int', 'i64', 'i32', 'i16', 'i8', 'u64', 'u32', 'u16', 'u8', 'f32', 'f64',
-			'voidptr', 'charptr', 'byteptr', 'usize', 'isize', 'rune', 'bool'] {
+			'voidptr', 'charptr', 'byteptr', 'usize', 'isize', 'rune', 'bool', 'char', 'byte'] {
 			// Type cast: just evaluate the expression (enums are already ints in SSA)
 			return b.expr(node.expr)
 		}

vlib/v2/transformer/transformer.v

@@ -5310,6 +5310,18 @@ fn (t &Transformer) strip_pos(e ast.Expr) ast.Expr {
 				name: e.name
 			}
 		}
+		ast.PrefixExpr {
+			return ast.PrefixExpr{
+				op:   e.op
+				expr: t.strip_pos(e.expr)
+			}
+		}
+		ast.CastExpr {
+			return ast.CastExpr{
+				typ:  e.typ
+				expr: t.strip_pos(e.expr)
+			}
+		}
 		else {
 			return e
 		}
@@ -10680,7 +10692,7 @@ fn (t &Transformer) get_module_scope(module_name string) ?&types.Scope {
 fn (t &Transformer) is_cast_type_name(name string) bool {
 	// Built-in primitive types
 	if name in ['int', 'i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64', 'bool',
-		'byte', 'rune', 'usize', 'isize', 'string', 'byteptr', 'charptr', 'voidptr'] {
+		'byte', 'char', 'rune', 'usize', 'isize', 'string', 'byteptr', 'charptr', 'voidptr'] {
 		return true
 	}
 	// Type names start with uppercase in V

vlib/v2/types/checker.v

@@ -757,7 +757,7 @@ fn (mut c Checker) expr_impl(expr ast.Expr) Type {
 			// c.log('ast.BasicLiteral: ${expr.kind.str()}: ${expr.value}')
 			match expr.kind {
 				.char {
-					return Type(char_)
+					return Type(rune_)
 				}
 				.key_false, .key_true {
 					return bool_
@@ -1114,10 +1114,10 @@ fn (mut c Checker) expr_impl(expr ast.Expr) Type {
 			return c.expr(expr.expr)
 		}
 		ast.RangeExpr {
-			c.expr(expr.start)
+			start_type := c.expr(expr.start)
 			c.expr(expr.end)
 			return Type(Array{
-				elem_type: int_
+				elem_type: start_type
 			})
 		}
 		ast.SelectExpr {