cgen, checker: fix $(field.name) access on closure fn (fix #25513) (#25514)

felipensp · web-flow · commit 5ac3852c944a · 2025-10-16T16:41:39.000+03:00
diff --git a/cmd/tools/vast/vast.v b/cmd/tools/vast/vast.v
@@ -653,6 +653,7 @@ fn (t Tree) anon_fn(node ast.AnonFn) &Node {
 	obj.add_terse('decl', t.fn_decl(node.decl))
 	obj.add('inherited_vars', t.array_node_arg(node.inherited_vars))
 	obj.add_terse('typ', t.type_node(node.typ))
+	obj.add('has_ct_var', t.bool_node(node.has_ct_var))
 	mut symbol_obj := create_object()
 	for key, val in node.has_gen {
 		symbol_obj.add_terse(key.str(), t.bool_node(val))
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
@@ -572,6 +572,7 @@ pub struct AnonFn {
 pub mut:
 	decl           FnDecl
 	inherited_vars []Param         // note: closures have inherited_vars.len > 0
+	has_ct_var     bool            // has $for var as inherited var
 	typ            Type            // the type of anonymous fn. Both .typ and .decl.name are auto generated
 	has_gen        map[string]bool // a map of the names of all generic anon functions, generated from it
 }
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -690,6 +690,8 @@ fn (mut c Checker) anon_fn(mut node ast.AnonFn) ast.Type {
 		} else {
 			parent_var.typ
 		}
+		node.has_ct_var = node.has_ct_var
+			|| var.name in [c.comptime.comptime_for_field_var, c.comptime.comptime_for_method_var]
 		if parent_var.typ != ast.no_type {
 			parent_var_sym := c.table.final_sym(ptyp)
 			if parent_var_sym.info is ast.FnType {
diff --git a/vlib/v/gen/c/assign.v b/vlib/v/gen/c/assign.v
@@ -1226,7 +1226,7 @@ fn (mut g Gen) gen_cross_var_assign(node &ast.AssignStmt) {
 				left_typ := node.left_types[i]
 				left_sym := g.table.sym(left_typ)
 				mut anon_ctx := ''
-				if g.anon_fn {
+				if g.anon_fn != unsafe { nil } {
 					if obj := left.scope.find_var(left.name) {
 						if obj.is_inherited {
 							anon_ctx = '${closure_ctx}->'
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -248,7 +248,7 @@ mut:
 	expected_cast_type  ast.Type // for match expr of sumtypes
 	expected_arg_mut    bool     // generating a mutable fn parameter
 	or_expr_return_type ast.Type // or { 0, 1 } return type
-	anon_fn             bool
+	anon_fn             &ast.AnonFn
 	tests_inited        bool
 	has_main            bool
 	// main_fn_decl_node  ast.FnDecl
@@ -346,6 +346,7 @@ pub fn gen(files []&ast.File, mut table ast.Table, pref_ &pref.Preferences) GenO
 		table:                table
 		pref:                 pref_
 		fn_decl:              unsafe { nil }
+		anon_fn:              unsafe { nil }
 		is_autofree:          pref_.autofree
 		indent:               -1
 		module_built:         module_built
@@ -845,6 +846,7 @@ fn cgen_process_one_file_cb(mut p pool.PoolProcessor, idx int, wid int) &Gen {
 		table:                 global_g.table
 		pref:                  global_g.pref
 		fn_decl:               unsafe { nil }
+		anon_fn:               unsafe { nil }
 		indent:                -1
 		module_built:          global_g.module_built
 		timers:                util.new_timers(
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
@@ -181,7 +181,7 @@ fn (mut g Gen) gen_fn_decl(node &ast.FnDecl, skip bool) {
 	}
 
 	tmp_defer_vars := g.defer_vars // must be here because of workflow
-	if !g.anon_fn {
+	if g.anon_fn == unsafe { nil } {
 		g.defer_vars = []string{}
 	} else {
 		if node.defer_stmts.len > 0 {
@@ -582,8 +582,7 @@ fn (mut g Gen) c_fn_name(node &ast.FnDecl) string {
 			name = name.replace_each(c_fn_name_escape_seq)
 		}
 	}
-	if node.is_anon && g.comptime.comptime_for_method_var != ''
-		&& node.scope.is_inherited_var('method') {
+	if node.is_anon && g.anon_fn.has_ct_var {
 		name = '${name}_${g.comptime.comptime_loop_id}'
 	}
 	if node.language == .c {
@@ -621,8 +620,7 @@ fn (mut g Gen) gen_closure_fn_name(node ast.AnonFn) string {
 	if node.decl.generic_names.len > 0 {
 		fn_name = g.generic_fn_name(g.cur_concrete_types, fn_name)
 	}
-	if node.inherited_vars.len > 0 && g.comptime.comptime_for_method_var != ''
-		&& node.inherited_vars.any(it.name == 'method') {
+	if node.has_ct_var {
 		fn_name += '_${g.comptime.comptime_loop_id}'
 	}
 	return fn_name
@@ -742,7 +740,7 @@ fn (mut g Gen) gen_anon_fn_decl(mut node ast.AnonFn) {
 	}
 	pos := g.out.len
 	was_anon_fn := g.anon_fn
-	g.anon_fn = true
+	g.anon_fn = node
 	g.fn_decl(node.decl)
 	g.anon_fn = was_anon_fn
 	builder.write_string(g.out.cut_to(pos))
diff --git a/vlib/v/tests/comptime/comptime_closure_field_access_test.v b/vlib/v/tests/comptime/comptime_closure_field_access_test.v
@@ -0,0 +1,23 @@
+struct TestObj {
+mut:
+	a int
+	b int
+}
+
+fn test_main() {
+	x := &TestObj{
+		a: 1
+		b: 1
+	}
+	$for field in TestObj.fields {
+		run_fn(fn [x, field] () {
+			(*x).$(field.name) += 1
+		})
+	}
+	assert x.a == 2
+	assert x.b == 2
+}
+
+fn run_fn(f fn ()) {
+	f()
+}

Original file line number	Diff line number	Diff line change
`@@ -572,6 +572,7 @@ pub struct AnonFn {`
`572`	`572`	`pub mut:`
`573`	`573`	`decl FnDecl`
`574`	`574`	`inherited_vars []Param // note: closures have inherited_vars.len > 0`
	`575`	`+ has_ct_var bool // has $for var as inherited var`
`575`	`576`	`typ Type // the type of anonymous fn. Both .typ and .decl.name are auto generated`
`576`	`577`	`has_gen map[string]bool // a map of the names of all generic anon functions, generated from it`
`577`	`578`	`}`
Original file line number	Diff line number	Diff line change
`@@ -690,6 +690,8 @@ fn (mut c Checker) anon_fn(mut node ast.AnonFn) ast.Type {`
`690`	`690`	`} else {`
`691`	`691`	`parent_var.typ`
`692`	`692`	`}`
	`693`	`+ node.has_ct_var = node.has_ct_var`
	`694`	`+ \|\| var.name in [c.comptime.comptime_for_field_var, c.comptime.comptime_for_method_var]`
`693`	`695`	`if parent_var.typ != ast.no_type {`
`694`	`696`	`parent_var_sym := c.table.final_sym(ptyp)`
`695`	`697`	`if parent_var_sym.info is ast.FnType {`
Original file line number	Diff line number	Diff line change
`@@ -181,7 +181,7 @@ fn (mut g Gen) gen_fn_decl(node &ast.FnDecl, skip bool) {`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`tmp_defer_vars := g.defer_vars // must be here because of workflow`
`184`		`- if !g.anon_fn {`
	`184`	`+ if g.anon_fn == unsafe { nil } {`
`185`	`185`	`g.defer_vars = []string{}`
`186`	`186`	`} else {`
`187`	`187`	`if node.defer_stmts.len > 0 {`
`@@ -582,8 +582,7 @@ fn (mut g Gen) c_fn_name(node &ast.FnDecl) string {`
`582`	`582`	`name = name.replace_each(c_fn_name_escape_seq)`
`583`	`583`	`}`
`584`	`584`	`}`
`585`		`- if node.is_anon && g.comptime.comptime_for_method_var != ''`
`586`		`- && node.scope.is_inherited_var('method') {`
	`585`	`+ if node.is_anon && g.anon_fn.has_ct_var {`
`587`	`586`	`name = '${name}_${g.comptime.comptime_loop_id}'`
`588`	`587`	`}`
`589`	`588`	`if node.language == .c {`
`@@ -621,8 +620,7 @@ fn (mut g Gen) gen_closure_fn_name(node ast.AnonFn) string {`
`621`	`620`	`if node.decl.generic_names.len > 0 {`
`622`	`621`	`fn_name = g.generic_fn_name(g.cur_concrete_types, fn_name)`
`623`	`622`	`}`
`624`		`- if node.inherited_vars.len > 0 && g.comptime.comptime_for_method_var != ''`
`625`		`- && node.inherited_vars.any(it.name == 'method') {`
	`623`	`+ if node.has_ct_var {`
`626`	`624`	`fn_name += '_${g.comptime.comptime_loop_id}'`
`627`	`625`	`}`
`628`	`626`	`return fn_name`
`@@ -742,7 +740,7 @@ fn (mut g Gen) gen_anon_fn_decl(mut node ast.AnonFn) {`
`742`	`740`	`}`
`743`	`741`	`pos := g.out.len`
`744`	`742`	`was_anon_fn := g.anon_fn`
`745`		`- g.anon_fn = true`
	`743`	`+ g.anon_fn = node`
`746`	`744`	`g.fn_decl(node.decl)`
`747`	`745`	`g.anon_fn = was_anon_fn`
`748`	`746`	`builder.write_string(g.out.cut_to(pos))`