v2: test-self

Author: medvednikov

cmd/v2/v2.v

@@ -4,17 +4,22 @@
 module main
 
 import os
+import time
 import v2.pref
 import v2.builder
 
 fn main() {
 	compile_args, runtime_args := split_eval_runtime_args(os.args[1..])
 
-	// Check for 'ast' subcommand
+	// Check for subcommands
 	if compile_args.len > 0 && compile_args[0] == 'ast' {
 		run_ast_command(compile_args[1..])
 		return
 	}
+	if compile_args.len > 0 && compile_args[0] == 'test-self' {
+		run_test_self()
+		return
+	}
 
 	mut prefs := pref.new_preferences_from_args(compile_args)
 
@@ -119,3 +124,128 @@ fn get_files(args []string) []string {
 	}
 	return files
 }
+
+fn resolve_own_path() string {
+	arg0 := os.args[0]
+	if os.is_abs_path(arg0) {
+		return arg0
+	}
+	return os.join_path(os.getwd(), arg0)
+}
+
+// detect_vroot walks up from `start` looking for a directory containing vlib/builtin.
+fn detect_vroot(start string) string {
+	mut dir := start
+	if !os.is_abs_path(dir) {
+		dir = os.join_path(os.getwd(), dir)
+	}
+	for _ in 0 .. 10 {
+		if os.is_dir(os.join_path(dir, 'vlib', 'builtin')) {
+			return dir
+		}
+		parent := os.dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
+	}
+	return dir
+}
+
+fn run_test_self() {
+	t0 := time.now()
+	// Resolve the v2 binary's own path. Cannot use @VEXE because when v1
+	// compiles v2, @VEXE bakes in v1's path instead of v2's.
+	vexe := resolve_own_path()
+	// Walk up from the binary to find the repo root (directory containing vlib/builtin).
+	// This allows running from subdirectories like cmd/v2/.
+	vroot := detect_vroot(vexe)
+	v2_dir := os.join_path(vroot, 'cmd', 'v2')
+
+	mut all_test_files := []string{}
+
+	// Builtin test files
+	for name in ['array_test.v', 'string_test.v', 'map_test.v'] {
+		all_test_files << os.join_path(vroot, 'vlib', 'builtin', name)
+	}
+
+	// Math test
+	all_test_files << os.join_path(vroot, 'vlib', 'math', 'math_test.v')
+
+	// Sumtype tests in cmd/v2/
+	v2_files := os.ls(v2_dir) or { []string{} }
+	for file in v2_files {
+		if file.starts_with('test_sumtype') && file.ends_with('.v') {
+			all_test_files << os.join_path(v2_dir, file)
+		}
+	}
+
+	// Cleanc regression tests
+	cleanc_tests_dir := os.join_path(vroot, 'vlib', 'v2', 'gen', 'cleanc', 'tests')
+	cleanc_files := os.ls(cleanc_tests_dir) or { []string{} }
+	for file in cleanc_files {
+		if file.ends_with('.v') && file != 'run_tests.v' {
+			all_test_files << os.join_path(cleanc_tests_dir, file)
+		}
+	}
+
+	total := all_test_files.len
+	mut passed := 0
+	mut failed := 0
+	mut failed_files := []string{}
+
+	eprintln('---- v2 test-self: ${total} test files ----')
+
+	for i, test_file in all_test_files {
+		short_name := test_file.replace(vroot + '/', '')
+		t1 := time.now()
+
+		// Determine output binary path
+		base := os.file_name(test_file).all_before_last('.v')
+		out_bin := os.join_path(os.temp_dir(), 'v2_test_self_${base}')
+
+		// Compile (use os.system to avoid pipe deadlocks with popen/GC)
+		compile_cmd := '${vexe} -o ${out_bin} "${test_file}" > /dev/null 2>&1'
+		compile_ret := os.system(compile_cmd)
+		compile_ms := f64(time.since(t1)) / f64(time.millisecond)
+
+		if compile_ret != 0 || !os.exists(out_bin) {
+			failed++
+			failed_files << short_name
+			eprintln(' FAIL  [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms  ${short_name}')
+			os.rm(out_bin) or {}
+			os.rm('${out_bin}.c') or {}
+			continue
+		}
+
+		// Run the compiled binary
+		t2 := time.now()
+		run_ret := os.system(out_bin + ' > /dev/null 2>&1')
+		run_ms := f64(time.since(t2)) / f64(time.millisecond)
+
+		if run_ret != 0 {
+			failed++
+			failed_files << short_name
+			eprintln(' FAIL  [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms, R: ${run_ms:7.1} ms  ${short_name}')
+		} else {
+			passed++
+			eprintln('OK    [${i + 1:4}/${total}] C: ${compile_ms:7.1} ms, R: ${run_ms:7.1} ms  ${short_name}')
+		}
+
+		os.rm(out_bin) or {}
+		os.rm('${out_bin}.c') or {}
+	}
+
+	elapsed := time.since(t0)
+	eprintln('------------------------------------------------------------------------')
+	eprintln('${passed} passed, ${failed} failed, ${total} total  (${elapsed})')
+	if failed_files.len > 0 {
+		eprintln('Failed:')
+		for f in failed_files {
+			eprintln('  ${f}')
+		}
+	}
+	if failed > 0 {
+		exit(1)
+	}
+}

vlib/v2/builder/cache_headers.v

@@ -430,7 +430,6 @@ fn (mut b Builder) ensure_core_module_headers() {
 		header_source = merge_missing_source_fn_decls(header_source, source_fn_decls)
 		source_struct_fields := b.source_struct_field_types_for_module(module_name)
 		header_source = repair_missing_struct_field_types(header_source, source_struct_fields)
-		header_source = ensure_ierror_interface_methods(header_source)
 		if header_source.len == 0 {
 			// Empty header would cause missing symbols in split compilation.
 			// Remove any partial headers already written and skip stamp update
@@ -1509,20 +1508,6 @@ fn merge_missing_source_fn_decls(header_source string, source_fn_decls map[strin
 	return merged
 }
 
-fn ensure_ierror_interface_methods(header_source string) string {
-	empty_pub := 'pub interface IError {\n}\n'
-	full_pub := 'pub interface IError {\n\tmsg fn() string\n\tcode fn() int\n}\n'
-	if header_source.contains(empty_pub) {
-		return header_source.replace(empty_pub, full_pub)
-	}
-	empty_plain := 'interface IError {\n}\n'
-	full_plain := 'interface IError {\n\tmsg fn() string\n\tcode fn() int\n}\n'
-	if header_source.contains(empty_plain) {
-		return header_source.replace(empty_plain, full_plain)
-	}
-	return header_source
-}
-
 fn header_struct_block_name(trimmed string) ?string {
 	if !trimmed.ends_with('{') {
 		return none

vlib/v2/gen/cleanc/cleanc.v

@@ -97,6 +97,7 @@ mut:
 	test_fn_names           []string                         // test function names collected in Pass 4
 	has_main                bool                             // whether a main() function was found in Pass 4
 	fn_owner_file           map[string]int                   // fn_key -> first file index (for parallel dedup)
+	global_owner_file       map[string]int                   // global_name -> first file index (for parallel dedup)
 	generic_struct_bindings map[string]map[string]types.Type // struct_name -> {T: concrete_type}
 	c_file_fn_keys          map[string]bool                  // fn_key -> emitted from a .c.v file, so plain .v fallback should be skipped
 	typedef_c_types         map[string]bool                  // C struct names with @[typedef] attribute (emit without 'struct' prefix)
@@ -1144,13 +1145,30 @@ pub fn (mut g Gen) gen_pass5_pre() []int {
 		g.gen_file_extern_globals(file)
 	}
 	// Emit extern consts for non-emitted modules, collect emittable file indices.
+	// Also build global_owner_file: assign each global to the first file that declares it
+	// so parallel workers can avoid emitting duplicate definitions.
 	mut emit_indices := []int{cap: g.files.len}
 	for fi, file in g.files {
 		g.set_file_module(file)
 		if !g.should_emit_module(g.cur_module) {
 			g.gen_file_extern_consts(file)
 		} else {
 			emit_indices << fi
+			for stmt in file.stmts {
+				if stmt is ast.GlobalDecl {
+					for field in stmt.fields {
+						gname := if g.cur_module != '' && g.cur_module != 'main'
+							&& g.cur_module != 'builtin' {
+							'${g.cur_module}__${field.name}'
+						} else {
+							field.name
+						}
+						if gname !in g.global_owner_file {
+							g.global_owner_file[gname] = fi
+						}
+					}
+				}
+			}
 		}
 	}
 	return emit_indices
@@ -1185,14 +1203,20 @@ pub fn (g &Gen) new_pass5_worker(file_indices []int, worker_id int) &Gen {
 	for fi in file_indices {
 		owned_files[fi] = true
 	}
-	// Clone emitted_types and reserve functions owned by other workers.
+	// Clone emitted_types and reserve functions/globals owned by other workers.
 	mut worker_emitted := g.emitted_types.clone()
 	mut blocked_fn_keys := map[string]bool{}
 	for fn_key, owner_fi in g.fn_owner_file {
 		if owner_fi !in owned_files {
 			blocked_fn_keys[fn_key] = true
 		}
 	}
+	// Block globals owned by other workers to prevent duplicate definitions.
+	for gname, owner_fi in g.global_owner_file {
+		if owner_fi !in owned_files {
+			worker_emitted['global_${gname}'] = true
+		}
+	}
 	return &Gen{
 		files: g.files
 		env:   unsafe { g.env }

vlib/v2/gen/cleanc/expr.v

@@ -3154,6 +3154,22 @@ fn (g &Gen) eval_comptime_cond(cond ast.Expr) bool {
 			if cond.op == .logical_or {
 				return g.eval_comptime_cond(cond.lhs) || g.eval_comptime_cond(cond.rhs)
 			}
+			// Handle `$if T is i8` — comptime generic type check
+			if cond.op == .key_is || cond.op == .not_is {
+				if cond.lhs is ast.Ident && cond.rhs is ast.Ident {
+					if concrete := g.active_generic_types[cond.lhs.name] {
+						concrete_name := concrete.name()
+						target_name := cond.rhs.name
+						// Normalize type aliases: byte == u8, int == i32
+						matched := concrete_name == target_name
+							|| (target_name == 'byte' && concrete_name == 'u8')
+							|| (target_name == 'u8' && concrete_name == 'byte')
+							|| (target_name == 'int' && concrete_name == 'i32')
+							|| (target_name == 'i32' && concrete_name == 'int')
+						return if cond.op == .key_is { matched } else { !matched }
+					}
+				}
+			}
 		}
 		ast.PostfixExpr {
 			if cond.op == .question && cond.expr is ast.Ident {

vlib/v2/gen/cleanc/fn.v

@@ -639,7 +639,7 @@ fn (mut g Gen) specialized_fn_name(node ast.FnDecl, generic_types map[string]typ
 	if suffixes.len == 0 {
 		return base_name
 	}
-	return '${base_name}_${suffixes.join('_')}'
+	return '${base_name}_T_${suffixes.join('_')}'
 }
 
 fn (g &Gen) generic_key_matches_decl(node ast.FnDecl, key string) bool {
@@ -934,7 +934,7 @@ fn (g &Gen) find_specialized_call_name(name string, token string) ?string {
 	if name == '' || token == '' {
 		return none
 	}
-	candidate := '${name}_${token}'
+	candidate := '${name}_T_${token}'
 	if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
 		return candidate
 	}
@@ -964,7 +964,7 @@ fn (mut g Gen) try_specialize_generic_call_name(name string, call_args []ast.Exp
 			arg_type_name = (g.get_local_var_c_type(base_arg.name) or { '' }).trim_space().trim_right('*')
 		}
 		if arg_type_name == 'string' {
-			candidate := '${name}_string'
+			candidate := '${name}_T_string'
 			if candidate in g.fn_param_is_ptr || candidate in g.fn_return_types {
 				return candidate
 			}
@@ -1009,7 +1009,7 @@ fn (mut g Gen) try_specialize_generic_call_name(name string, call_args []ast.Exp
 		mut changed := false
 		for i, part in parts {
 			if concrete := g.active_generic_types[part] {
-				parts[i] = g.generic_specialization_token_from_type(concrete)
+				parts[i] = 'T_${g.generic_specialization_token_from_type(concrete)}'
 				changed = true
 			}
 		}
@@ -1261,6 +1261,11 @@ fn (mut g Gen) gen_fn_decl_ptr(node &ast.FnDecl) {
 		g.active_generic_types = prev_generic_types.clone()
 	}
 	if g.generic_fn_param_names(*node).len > 0 {
+		// maxof[T]/minof[T] are compile-time functions fully inlined by the transformer.
+		// Skip emitting stub bodies (which contain invalid C).
+		if node.name in ['maxof', 'minof'] {
+			return
+		}
 		prev_generic_types := g.active_generic_types.clone()
 		for spec in g.generic_fn_specializations(*node) {
 			g.active_generic_types = spec.generic_types.clone()
@@ -4750,10 +4755,12 @@ fn (mut g Gen) emit_generic_fn_macro(fn_name string, node ast.FnDecl) {
 				|| stub_ret.starts_with('Array_fixed_') {
 				stub_ret = 'array'
 			}
-			// Emit a stub that aborts at runtime with a clear message instead
-			// of silently returning a zero value.  This surfaces missing
-			// generic specialization bugs immediately rather than hiding them.
+			// Emit a stub that surfaces missing generic specializations both
+			// at compile time (#warning) and at runtime (abort).
 			g.sb.writeln('/* unresolved generic */ ${stub_ret} ${fn_name}() {')
+			g.sb.writeln('#if !defined(__TINYC__)')
+			g.sb.writeln('#warning "v2: unresolved generic stub: ${fn_name}"')
+			g.sb.writeln('#endif')
 			g.sb.writeln('\tfputs("v2: unresolved generic call: ${fn_name}\\n", stderr);')
 			g.sb.writeln('\tabort();')
 			if stub_ret != 'void' {

vlib/v2/transformer/fn.v

@@ -1802,7 +1802,9 @@ fn (t &Transformer) resolve_method_call_name(receiver ast.Expr, method_name stri
 	}
 	// Self-hosted ARM64 builds can misresolve byte-oriented receivers as `i8`
 	// even though the builtin helper methods are declared on `u8`.
-	if c_prefix == 'i8' && t.lookup_method_cached('u8', method_name) != none {
+	// Only fall back to u8 when i8 has no method of its own (e.g. bytestr, hex).
+	if c_prefix == 'i8' && t.lookup_method_cached('i8', method_name) == none
+		&& t.lookup_method_cached('u8', method_name) != none {
 		c_prefix = 'u8'
 	}
 	if c_prefix == '' {
@@ -2867,6 +2869,15 @@ fn (t &Transformer) get_enum_type(expr ast.Expr) string {
 			return t.type_to_c_name(base)
 		}
 	}
+	// Fallback: for SelectorExpr (struct field access), resolve via struct field type
+	if expr is ast.SelectorExpr {
+		if field_type := t.get_struct_field_type(expr) {
+			base := t.unwrap_alias_and_pointer_type(field_type)
+			if base is types.Enum {
+				return t.type_to_c_name(base)
+			}
+		}
+	}
 	return ''
 }