v2: cleanc/transformer fixes

Author: medvednikov

vlib/gg/gg_darwin.m

@@ -59,7 +59,7 @@ gg__Size gg_get_screen_size() {
 }
 
 void darwin_draw_string(int x, int y, string s, gg__TextCfg cfg) {
-	NSFont* font = [NSFont userFontOfSize:0]; // cfg.size];
+	NSFont* font = [NSFont userFontOfSize:cfg.size];
 	// # NSFont*    font = [NSFont fontWithName:@"Roboto Mono" size:cfg.size];
 	if (cfg.mono) {
 		// # font = [NSFont fontWithName:@"Roboto Mono" size:cfg.size];

vlib/v2/gen/cleanc/cheaders.v

@@ -163,10 +163,8 @@ fn (mut g Gen) collect_directives_from_stmts(stmts []ast.Stmt, file_name string,
 
 fn (mut g Gen) collect_directives_from_expr(expr ast.Expr, file_name string, mut seen map[string]bool) {
 	if expr is ast.ComptimeExpr {
-		eprintln('[directives-debug] ComptimeExpr in ${file_name}')
 		g.collect_directives_from_expr(expr.expr, file_name, mut seen)
 	} else if expr is ast.IfExpr {
-		eprintln('[directives-debug] IfExpr in ${file_name}, stmts.len=${expr.stmts.len}')
 		g.collect_directives_from_stmts(expr.stmts, file_name, mut seen)
 		if expr.else_expr !is ast.EmptyExpr {
 			g.collect_directives_from_expr(expr.else_expr, file_name, mut seen)
@@ -400,22 +398,8 @@ fn (mut g Gen) emit_runtime_aliases() {
 		}
 		g.sb.writeln('typedef array ${name};')
 	}
-	// Emit pointer element typedefs needed by array helper functions.
-	// e.g. Array_Coordptr needs 'typedef Coord* Coordptr;'
-	// Must come after array aliases so Array_int etc. are defined first.
-	for name in array_names {
-		if name.starts_with('Array_fixed_') {
-			continue
-		}
-		elem := name['Array_'.len..]
-		if elem.len > 3 && elem.ends_with('ptr') {
-			base := elem[..elem.len - 3]
-			if base !in ['void', 'char', 'byte'] && !elem.starts_with('Array_')
-				&& !elem.starts_with('Map_') {
-				g.sb.writeln('typedef ${base}* ${elem};')
-			}
-		}
-	}
+	// Pointer element typedefs (e.g. 'typedef Coord* Coordptr;') are deferred
+	// to emit_pointer_typedefs() which runs after pass 2 (enum/alias definitions).
 	// Emit primitive fixed array typedefs (non-primitive ones deferred until after struct defs)
 	for name in array_names {
 		if !name.starts_with('Array_fixed_') {
@@ -481,6 +465,27 @@ fn (mut g Gen) emit_runtime_aliases() {
 	}
 }
 
+// emit_pointer_typedefs emits pointer element typedefs needed by array helper functions.
+// e.g. Array_Coordptr needs 'typedef Coord* Coordptr;'.
+// Must run AFTER pass 2 so that enum and type alias definitions are available.
+fn (mut g Gen) emit_pointer_typedefs() {
+	mut array_names := g.array_aliases.keys()
+	array_names.sort()
+	for name in array_names {
+		if name.starts_with('Array_fixed_') {
+			continue
+		}
+		elem := name['Array_'.len..]
+		if elem.len > 3 && elem.ends_with('ptr') {
+			base := elem[..elem.len - 3]
+			if base !in ['void', 'char', 'byte'] && !elem.starts_with('Array_')
+				&& !elem.starts_with('Map_') {
+				g.sb.writeln('typedef ${base}* ${elem};')
+			}
+		}
+	}
+}
+
 fn (mut g Gen) get_enum_name(node ast.EnumDecl) string {
 	if g.cur_module != '' && g.cur_module != 'main' && g.cur_module != 'builtin' {
 		return '${g.cur_module}__${node.name}'

vlib/v2/gen/cleanc/cleanc.v

@@ -30,6 +30,15 @@ mut:
 	runtime_local_types    map[string]string
 	cur_fn_returned_idents map[string]bool
 	active_generic_types   map[string]types.Type
+	// Comptime $for field iteration state
+	comptime_field_var      string // variable name (e.g., 'field')
+	comptime_field_name     string // current field name (e.g., 'id')
+	comptime_field_type     string // current field C type name
+	comptime_field_raw_type types.Type = types.Struct{} // raw types.Type for comptime checks
+	comptime_field_attrs    []string // current field attributes
+	comptime_field_idx      int      // current field index
+	comptime_val_var        string   // the struct variable being decoded (e.g., 'val')
+	comptime_val_type       string   // C type of val (e.g., 'Slack')
 
 	fixed_array_fields          map[string]bool
 	fixed_array_field_elem      map[string]string
@@ -76,21 +85,25 @@ mut:
 	resolved_module_names       map[string]string  // per-function cache for resolve_module_name
 	cached_env_scopes           map[string]voidptr // cache of env_scope results (avoids repeated locking)
 
-	const_exprs           map[string]string // const name → C expression string (for inlining)
-	const_types           map[string]string // const name → C type string
-	runtime_const_targets map[string]bool   // module-scoped consts initialized in __v_init_consts_*
-	used_fn_keys          map[string]bool
-	force_emit_fn_names   map[string]bool   // function C names that must be emitted regardless of mark_used
-	export_fn_names       map[string]string // V-qualified name → export name (from @[export:] attribute)
-	called_fn_names       map[string]bool
-	generic_spec_index    map[string][]string // fn_name → matching keys in env.generic_types
-	anon_fn_defs          []string            // lifted anonymous function definitions
-	pass5_start_pos       int                 // position in sb where pass 5 starts
-	deferred_m_includes   []string            // Objective-C .m file #include lines deferred until after type definitions
-	spawned_fns           map[string]bool     // spawn wrapper names already emitted
-	spawn_wrapper_defs    []string            // spawn wrapper struct + function definitions
-	emitted_trampolines   map[string]bool     // bound method trampoline names already emitted
-	trampoline_defs       []string            // bound method trampoline definitions
+	const_exprs                map[string]string // const name → C expression string (for inlining)
+	const_types                map[string]string // const name → C type string
+	runtime_const_targets      map[string]bool   // module-scoped consts initialized in __v_init_consts_*
+	used_fn_keys               map[string]bool
+	force_emit_fn_names        map[string]bool   // function C names that must be emitted regardless of mark_used
+	export_fn_names            map[string]string // V-qualified name → export name (from @[export:] attribute)
+	called_fn_names            map[string]bool
+	generic_spec_index         map[string][]string                // fn_name → matching keys in env.generic_types
+	late_generic_specs         map[string][]map[string]types.Type // additional comptime-discovered specs
+	anon_fn_defs               []string        // lifted anonymous function definitions
+	late_struct_defs           []string        // struct definitions discovered during pass 5 codegen
+	pending_late_body_keys     map[string]bool // body_keys in late_struct_defs but not yet flushed to g.sb
+	late_generic_str_instances []string        // c_names of late generic struct instances needing str macro check
+	pass5_start_pos            int             // position in sb where pass 5 starts
+	deferred_m_includes        []string        // Objective-C .m file #include lines deferred until after type definitions
+	spawned_fns                map[string]bool // spawn wrapper names already emitted
+	spawn_wrapper_defs         []string        // spawn wrapper struct + function definitions
+	emitted_trampolines        map[string]bool // bound method trampoline names already emitted
+	trampoline_defs            []string        // bound method trampoline definitions
 	// @[live] hot code reloading
 	live_fns                []LiveFnInfo                     // @[live] functions detected during code generation
 	live_source_file        string                           // source file containing @[live] functions
@@ -99,10 +112,20 @@ mut:
 	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)
-	blocked_fn_keys         map[string]bool                  // worker-only fn keys reserved to other pass5 chunks
-	cached_vhash            string // cached git short hash for @VHASH/@VCURRENTHASH
+	// Multi-instantiation support: maps base struct C name (e.g. "json2__Node") to
+	// a list of (suffix, bindings) pairs for each distinct concrete instantiation.
+	// E.g. [("json2__ValueInfo", {T: ValueInfo}), ("json2__StructFieldInfo", {T: StructFieldInfo})]
+	generic_struct_instances map[string][]GenericStructInstance
+	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)
+	blocked_fn_keys          map[string]bool // worker-only fn keys reserved to other pass5 chunks
+	cached_vhash             string          // cached git short hash for @VHASH/@VCURRENTHASH
+}
+
+struct GenericStructInstance {
+	params_key string                // e.g. "json2__ValueInfo" — unique key per instantiation
+	bindings   map[string]types.Type // e.g. {T: ValueInfo}
+	c_name     string                // full C struct name, e.g. "json2__Node_T_json2__StructFieldInfo"
 }
 
 struct LiveFnInfo {
@@ -534,9 +557,9 @@ pub fn (mut g Gen) gen_passes_1_to_4() {
 
 	g.write_preamble()
 	g.collect_typedef_c_types()
+	g.collect_generic_struct_bindings()
 	g.collect_module_type_names()
 	g.collect_runtime_aliases()
-	g.collect_generic_struct_bindings()
 	// Force eventbus generic structs to use T=string binding.
 	// Without full monomorphization, eventbus methods assume T=string
 	// (see fn.v hardcoded eventbus workaround).
@@ -552,6 +575,7 @@ pub fn (mut g Gen) gen_passes_1_to_4() {
 	g.generic_struct_bindings['stdatomic__AtomicVal'] = {
 		'T': types.Type(types.f64_)
 	}
+	g.discover_comptime_generic_specs()
 	g.collect_fn_signatures()
 	g.collect_c_file_fn_keys()
 	g.collect_runtime_const_targets()
@@ -597,6 +621,19 @@ pub fn (mut g Gen) gen_passes_1_to_4() {
 				g.emitted_types[name] = true
 				keyword := if stmt.is_union { 'union' } else { 'struct' }
 				g.sb.writeln('typedef ${keyword} ${name} ${name};')
+				// Also emit forward declarations for additional generic instances
+				if stmt.generic_params.len > 0 {
+					instances := g.generic_struct_instances[name]
+					for inst in instances {
+						if inst.c_name == name {
+							continue
+						}
+						if inst.c_name !in g.emitted_types {
+							g.emitted_types[inst.c_name] = true
+							g.sb.writeln('typedef ${keyword} ${inst.c_name} ${inst.c_name};')
+						}
+					}
+				}
 			} else if stmt is ast.TypeDecl {
 				if stmt.variants.len > 0 {
 					// Sum type needs forward struct declaration
@@ -676,6 +713,10 @@ pub fn (mut g Gen) gen_passes_1_to_4() {
 	stage_start = g.mark_cgen_step(stats_enabled, stats_scope, mut stats_sw, stage_start,
 		'pass 2 type declarations')
 
+	// Emit pointer element typedefs (e.g. 'typedef Color* Colorptr;') now that
+	// enums and type aliases have been defined.
+	g.emit_pointer_typedefs()
+
 	// Pass 3: Full struct definitions (use named struct/union to match forward decls)
 	// Collect all struct decls, then emit in dependency order
 	mut all_structs := []StructDeclInfo{}
@@ -756,6 +797,9 @@ pub fn (mut g Gen) gen_passes_1_to_4() {
 		'pass 3.1 fixed arrays')
 
 	// Pass 3.25: Tuple aliases (multiple-return lowering support)
+	if 'body_array' !in g.emitted_types {
+		eprintln('WARNING: body_array not emitted before pass 3.25 tuples')
+	}
 	g.emit_tuple_aliases()
 	if g.tuple_aliases.len > 0 {
 		g.sb.writeln('')
@@ -1088,10 +1132,35 @@ pub fn (mut g Gen) gen_finalize() string {
 	g.emit_exported_const_symbols()
 
 	mut out := ''
-	if g.anon_fn_defs.len > 0 || g.spawn_wrapper_defs.len > 0 || g.trampoline_defs.len > 0 {
+	// Emit deferred str macros for late-discovered generic struct instances.
+	// At this point fn_return_types is fully populated (pass 4 complete).
+	for inst_name in g.late_generic_str_instances {
+		str_fn := '${inst_name}__str'
+		if str_fn !in g.fn_return_types {
+			label := '${inst_name}{}'
+			g.late_struct_defs << '#define ${inst_name}__str(v) ((string){.str = "${label}", .len = ${label.len}, .is_lit = 1})\n#define ${inst_name}_str(v) ${inst_name}__str(v)\n'
+		}
+	}
+	if g.anon_fn_defs.len > 0 || g.spawn_wrapper_defs.len > 0 || g.trampoline_defs.len > 0
+		|| g.late_struct_defs.len > 0 || g.pending_late_body_keys.len > 0 {
 		full := g.sb.str()
 		mut out_sb := strings.new_builder(full.len + 4096)
 		unsafe { out_sb.write_ptr(full.str, g.pass5_start_pos) }
+		// Late-discovered generic struct definitions (discovered during setup/pass 4 codegen)
+		for def in g.late_struct_defs {
+			out_sb.write_string(def)
+		}
+		// Mark pending late body keys as emitted now that they're in the output.
+		for key, _ in g.pending_late_body_keys {
+			g.emitted_types[key] = true
+		}
+		g.pending_late_body_keys = map[string]bool{}
+		// Emit any option/result wrappers that were deferred because their payload
+		// types were only in late_struct_defs. Temporarily swap sb with out_sb.
+		g.sb = out_sb
+		g.emit_option_result_structs()
+		out_sb = g.sb
+		g.sb = strings.new_builder(0)
 		mut seen_spawn_defs := map[string]bool{}
 		for def in g.spawn_wrapper_defs {
 			if def in seen_spawn_defs {
@@ -1263,6 +1332,9 @@ pub fn (g &Gen) new_pass5_worker(file_indices []int, worker_id int) &Gen {
 		export_fn_names:             g.export_fn_names.clone()
 		called_fn_names:             g.called_fn_names.clone()
 		generic_spec_index:          g.generic_spec_index.clone()
+		late_generic_specs:          g.late_generic_specs.clone()
+		generic_struct_bindings:     g.generic_struct_bindings.clone()
+		generic_struct_instances:    g.generic_struct_instances.clone()
 		typedef_c_types:             g.typedef_c_types.clone()
 		// Per-worker mutable state (starts fresh).
 		// Each worker gets a unique tmp_counter offset to avoid name collisions