vlib: use defer(fn) { syntax where appropriate (part 2 of #25639) (#25653)

StunxFS · web-flow · commit 82cd44e9d5a0 · 2025-11-04T17:26:29.000+02:00
diff --git a/cmd/tools/vbug.v b/cmd/tools/vbug.v
@@ -67,7 +67,7 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string, user_args
 	}
 	if result.exit_code == 0 {
 		real_generated_file := os.real_path(generated_file)
-		defer {
+		defer(fn) {
 			os.rm(generated_file) or {
 				if is_verbose {
 					elog('> unable to delete generated file: ${err}')
diff --git a/vlib/net/mbedtls/ssl_connection.c.v b/vlib/net/mbedtls/ssl_connection.c.v
@@ -522,7 +522,7 @@ pub fn (s &SSLConn) peer_addr() !net.Addr {
 pub fn (mut s SSLConn) socket_read_into_ptr(buf_ptr &u8, len int) !int {
 	mut res := 0
 	$if trace_ssl ? {
-		defer {
+		defer(fn) {
 			if len > 0 {
 				eprintln('${@METHOD} res: ${res}: buf_ptr: ${voidptr(buf_ptr):x}, len: ${len}, hex: ${unsafe { buf_ptr.vbytes(len).hex() }} data: `${unsafe { buf_ptr.vstring_with_len(len) }}`')
 			}
@@ -590,7 +590,7 @@ pub fn (mut s SSLConn) read(mut buffer []u8) !int {
 pub fn (mut s SSLConn) write_ptr(bytes &u8, len int) !int {
 	mut total_sent := 0
 	$if trace_ssl ? {
-		defer {
+		defer(fn) {
 			eprintln('${@METHOD} total_sent: ${total_sent}, bytes: ${voidptr(bytes):x}, len: ${len}, hex: ${unsafe { bytes.vbytes(len).hex() }}, data:-=-=-=-\n${unsafe { bytes.vstring_with_len(len) }}\n-=-=-=-')
 		}
 	}
diff --git a/vlib/net/openssl/ssl_connection.c.v b/vlib/net/openssl/ssl_connection.c.v
@@ -270,7 +270,7 @@ pub fn (s &SSLConn) peer_addr() !net.Addr {
 pub fn (mut s SSLConn) socket_read_into_ptr(buf_ptr &u8, len int) !int {
 	mut res := 0
 	$if trace_ssl ? {
-		defer {
+		defer(fn) {
 			if len > 0 {
 				eprintln('${@METHOD} res: ${res}: buf_ptr: ${voidptr(buf_ptr):x}, len: ${len}, hex: ${unsafe { buf_ptr.vbytes(len).hex() }} data: `${unsafe { buf_ptr.vstring_with_len(len) }}`')
 			}
@@ -338,7 +338,7 @@ pub fn (mut s SSLConn) read(mut buffer []u8) !int {
 pub fn (mut s SSLConn) write_ptr(bytes &u8, len int) !int {
 	mut total_sent := 0
 	$if trace_ssl ? {
-		defer {
+		defer(fn) {
 			eprintln('${@METHOD} total_sent: ${total_sent}, bytes: ${voidptr(bytes):x}, len: ${len}, hex: ${unsafe { bytes.vbytes(len).hex() }}, data:-=-=-=-\n${unsafe { bytes.vstring_with_len(len) }}\n-=-=-=-')
 		}
 	}
diff --git a/vlib/os/os.c.v b/vlib/os/os.c.v
@@ -753,7 +753,7 @@ pub fn executable() string {
 		if unsafe { C.sysctl(&mib[0], mib.len, C.NULL, &bufsize, C.NULL, 0) } == 0 {
 			if bufsize > max_path_buffer_size {
 				pbuf = unsafe { &&u8(malloc(int(bufsize))) }
-				defer {
+				defer(fn) {
 					unsafe { free(pbuf) }
 				}
 			}
@@ -856,9 +856,7 @@ pub fn real_path(fpath string) string {
 		}
 		file := C.CreateFile(fpath_wide, 0x80000000, 1, 0, 3, 0x80, 0)
 		if file != voidptr(-1) {
-			defer {
-				C.CloseHandle(file)
-			}
+			defer { C.CloseHandle(file) }
 			// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew
 			final_len := C.GetFinalPathNameByHandleW(file, pu16_fullpath, max_path_buffer_size,
 				0)
diff --git a/vlib/os/process_windows.c.v b/vlib/os/process_windows.c.v
@@ -152,7 +152,7 @@ fn (mut p Process) win_spawn_process() int {
 		}
 		env_block << u16(0)
 		creation_flags |= C.CREATE_UNICODE_ENVIRONMENT
-		defer {
+		defer(fn) {
 			unsafe { env_block.free() }
 		}
 	}
diff --git a/vlib/v/ast/table.v b/vlib/v/ast/table.v
@@ -907,7 +907,7 @@ fn (mut t Table) rewrite_already_registered_symbol(typ TypeSymbol, existing_idx
 pub fn (mut t Table) register_sym(sym TypeSymbol) int {
 	mut idx := -2
 	$if trace_register_sym ? {
-		defer {
+		defer(fn) {
 			eprintln('>> register_sym: ${sym.name:-60} | idx: ${idx}')
 		}
 	}
diff --git a/vlib/v/checker/assign.v b/vlib/v/checker/assign.v
@@ -207,7 +207,7 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 			mut expr := node.right[i]
 			if left is ast.Ident && left.is_mut() && expr is ast.StructInit && expr.is_anon {
 				c.anon_struct_should_be_mut = true
-				defer {
+				defer(fn) {
 					c.anon_struct_should_be_mut = false
 				}
 			}
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -3233,7 +3233,7 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {
 		ast.LambdaExpr {
 			c.inside_lambda = true
 			c.table.cur_lambda = unsafe { &node }
-			defer {
+			defer(fn) {
 				c.inside_lambda = false
 				c.table.cur_lambda = unsafe { nil }
 			}
diff --git a/vlib/v/checker/for.v b/vlib/v/checker/for.v
@@ -169,7 +169,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 				c.type_resolver.update_ct_type(node.val_var, val_type)
 				node.scope.update_ct_var_kind(node.val_var, .value_var)
 
-				defer {
+				defer(fn) {
 					c.type_resolver.type_map.delete(node.val_var)
 				}
 			}
@@ -194,7 +194,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 					c.type_resolver.update_ct_type(node.key_var, key_type)
 					node.scope.update_ct_var_kind(node.key_var, .key_var)
 
-					defer {
+					defer(fn) {
 						c.type_resolver.type_map.delete(node.key_var)
 					}
 				}
@@ -211,7 +211,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 				c.type_resolver.update_ct_type(node.val_var, value_type)
 				node.scope.update_ct_var_kind(node.val_var, .value_var)
 
-				defer {
+				defer(fn) {
 					c.type_resolver.type_map.delete(node.val_var)
 				}
 			}
@@ -236,7 +236,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 					c.type_resolver.update_ct_type(node.key_var, key_type)
 					node.scope.update_ct_var_kind(node.key_var, .key_var)
 
-					defer {
+					defer(fn) {
 						c.type_resolver.type_map.delete(node.key_var)
 					}
 				}
@@ -300,7 +300,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 				c.type_resolver.update_ct_type(node.val_var, value_type)
 				node.scope.update_ct_var_kind(node.val_var, .value_var)
 
-				defer {
+				defer(fn) {
 					c.type_resolver.type_map.delete(node.val_var)
 				}
 			}
diff --git a/vlib/v/checker/if.v b/vlib/v/checker/if.v
@@ -77,7 +77,7 @@ fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
 	former_expected_type := c.expected_type
 	if node_is_expr {
 		c.expected_expr_type = c.expected_type
-		defer {
+		defer(fn) {
 			c.expected_expr_type = ast.void_type
 		}
 	}
diff --git a/vlib/v/checker/infix.v b/vlib/v/checker/infix.v
@@ -95,7 +95,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 		&& right_type in [ast.int_literal_type, ast.float_literal_type] {
 		node.right_type = left_type
 		if left_type in [ast.f32_type_idx, ast.f64_type_idx] && right_type == ast.float_literal_type {
-			defer {
+			defer(fn) {
 				node.right = ast.CastExpr{
 					expr:      node.right
 					typ:       left_type
@@ -110,7 +110,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 		&& left_type in [ast.int_literal_type, ast.float_literal_type] {
 		node.left_type = right_type
 		if right_type in [ast.f32_type_idx, ast.f64_type_idx] && left_type == ast.float_literal_type {
-			defer {
+			defer(fn) {
 				node.left = ast.CastExpr{
 					expr:      node.left
 					typ:       right_type
diff --git a/vlib/v/checker/match.v b/vlib/v/checker/match.v
@@ -14,7 +14,7 @@ fn (mut c Checker) match_expr(mut node ast.MatchExpr) ast.Type {
 	}
 	if node.is_expr {
 		c.expected_expr_type = c.expected_type
-		defer {
+		defer(fn) {
 			c.expected_expr_type = ast.void_type
 		}
 	}
diff --git a/vlib/v/checker/struct.v b/vlib/v/checker/struct.v
@@ -510,7 +510,7 @@ fn (mut c Checker) struct_init(mut node ast.StructInit, is_field_zero_struct_ini
 			c.inside_generic_struct_init = true
 			c.cur_struct_generic_types = struct_sym.info.generic_types.clone()
 			c.cur_struct_concrete_types = struct_sym.info.concrete_types.clone()
-			defer {
+			defer(fn) {
 				c.inside_generic_struct_init = old_inside_generic_struct_init
 				c.cur_struct_generic_types = old_cur_struct_generic_types
 				c.cur_struct_concrete_types = old_cur_struct_concrete_types
diff --git a/vlib/v/fmt/fmt.v b/vlib/v/fmt/fmt.v
@@ -2055,7 +2055,7 @@ pub fn (mut f Fmt) call_expr(node ast.CallExpr) {
 	if node.is_method {
 		if node.name in ['map', 'filter', 'all', 'any', 'count'] {
 			f.in_lambda_depth++
-			defer { f.in_lambda_depth-- }
+			defer(fn) { f.in_lambda_depth-- }
 		}
 		f.expr(node.left)
 		is_method_newline = node.left.pos().last_line != node.name_pos.line_nr
diff --git a/vlib/v/gen/c/array.v b/vlib/v/gen/c/array.v
@@ -96,7 +96,7 @@ fn (mut g Gen) fixed_array_init(node ast.ArrayInit, array_type Type, var_name st
 	array_info := array_type.unaliased_sym.array_fixed_info()
 	if node.has_index {
 		past := g.past_tmp_var_from_var_name(var_name)
-		defer {
+		defer(fn) {
 			g.past_tmp_var_done(past)
 		}
 
@@ -150,7 +150,7 @@ fn (mut g Gen) fixed_array_init(node ast.ArrayInit, array_type Type, var_name st
 	if node.has_val {
 		tmp_inside_array := g.inside_array_item
 		g.inside_array_item = true
-		defer {
+		defer(fn) {
 			g.inside_array_item = tmp_inside_array
 		}
 		nelen := node.exprs.len
@@ -295,7 +295,7 @@ fn (mut g Gen) array_init_with_fields(node ast.ArrayInit, elem_type Type, is_amp
 	if node.has_index {
 		// []int{len: 6, init: index * index} when variable it is used in init expression
 		past := g.past_tmp_var_from_var_name(var_name)
-		defer {
+		defer(fn) {
 			g.past_tmp_var_done(past)
 		}
 
@@ -1841,7 +1841,7 @@ fn (mut g Gen) fixed_array_update_expr_field(expr_str string, field_type ast.Typ
 	elem_sym := g.table.sym(elem_type)
 	if !g.inside_array_fixed_struct {
 		g.write('{')
-		defer {
+		defer(fn) {
 			g.write('}')
 		}
 	}
@@ -1882,7 +1882,7 @@ fn (mut g Gen) fixed_array_var_init(expr_str string, is_auto_deref bool, elem_ty
 	elem_sym := g.table.sym(elem_type)
 	if !g.inside_array_fixed_struct {
 		g.write('{')
-		defer {
+		defer(fn) {
 			g.write('}')
 		}
 	}
diff --git a/vlib/v/gen/c/assign.v b/vlib/v/gen/c/assign.v
@@ -254,7 +254,7 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 					g.write('->val')
 				}
 				g.writeln('); // free ${type_to_free} on re-assignment2')
-				defer {
+				defer(fn) {
 					if af {
 						g.writeln('builtin__${type_to_free}_free(&${sref_name});')
 					}
@@ -536,7 +536,7 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 
 		g.left_is_opt = var_type.has_option_or_result()
 		g.right_is_opt = val_type.has_option_or_result()
-		defer {
+		defer(fn) {
 			g.left_is_opt = false
 			g.right_is_opt = false
 		}
@@ -951,7 +951,7 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 					&& ((var_type.has_flag(.option) && !val_type.has_flag(.option))
 					|| (var_type.has_flag(.result) && !val_type.has_flag(.result))) {
 					old_inside_opt_or_res := g.inside_opt_or_res
-					defer {
+					defer(fn) {
 						g.inside_opt_or_res = old_inside_opt_or_res
 					}
 					g.inside_opt_or_res = true
@@ -1051,7 +1051,7 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 				} else {
 					// var = &auto_heap_var
 					old_is_auto_heap := g.is_option_auto_heap
-					defer {
+					defer(fn) {
 						g.is_option_auto_heap = old_is_auto_heap
 					}
 					if val is ast.Ident && val.is_mut() && var_type.is_ptr() {
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -2929,7 +2929,7 @@ fn (mut g Gen) call_cfn_for_casting_expr(fname string, expr ast.Expr, exp ast.Ty
 				}
 				old_inside_smartcast := g.inside_smartcast
 				g.inside_smartcast = true
-				defer {
+				defer(fn) {
 					g.inside_smartcast = old_inside_smartcast
 				}
 			} else {
@@ -5313,7 +5313,7 @@ fn (mut g Gen) ident(node ast.Ident) {
 			styp := g.base_type(node.obj.typ)
 			g.write('(*(${styp}*)')
 
-			defer {
+			defer(fn) {
 				g.write('.data)')
 			}
 		}
@@ -7374,7 +7374,7 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type ast.Ty
 		}
 
 		g.inside_or_block = true
-		defer {
+		defer(fn) {
 			g.inside_or_block = false
 		}
 		stmts := or_block.stmts
diff --git a/vlib/v/gen/c/dumpexpr.v b/vlib/v/gen/c/dumpexpr.v
@@ -17,7 +17,7 @@ fn (mut g Gen) dump_expr(node ast.DumpExpr) {
 
 	if node.expr is ast.CallExpr {
 		g.inside_dump_fn = true
-		defer {
+		defer(fn) {
 			g.inside_dump_fn = false
 		}
 	}
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
@@ -11,7 +11,7 @@ const c_fn_name_escape_seq = ['[', '_T_', ']', '']
 
 fn (mut g Gen) is_used_by_main(node ast.FnDecl) bool {
 	$if trace_unused_by_main ? {
-		defer {
+		defer(fn) {
 			used_by_main := $res()
 			if !used_by_main {
 				fkey := node.fkey()
@@ -186,7 +186,7 @@ fn (mut g Gen) gen_fn_decl(node &ast.FnDecl, skip bool) {
 	} else {
 		if node.defer_stmts.len > 0 {
 			g.defer_vars = []string{}
-			defer {
+			defer(fn) {
 				g.defer_vars = tmp_defer_vars
 			}
 		}
@@ -2067,7 +2067,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 	if is_print && (node.args[0].typ != ast.string_type
 		|| g.comptime.comptime_for_method != unsafe { nil } || node.args[0].ct_expr) {
 		g.inside_interface_deref = true
-		defer {
+		defer(fn) {
 			g.inside_interface_deref = false
 		}
 		mut typ := g.type_resolver.get_type_or_default(node.args[0].expr, node.args[0].typ)
@@ -2133,7 +2133,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 	if !print_auto_str {
 		if is_print {
 			g.inside_interface_deref = true
-			defer {
+			defer(fn) {
 				g.inside_interface_deref = false
 			}
 		}
@@ -2311,7 +2311,7 @@ fn (mut g Gen) autofree_call_pregen(node ast.CallExpr) {
 		if !arg.is_tmp_autofree {
 			if arg.expr is ast.CallExpr && arg.expr.name in ['json.encode', 'json.encode_pretty'] {
 				t := '_arg_expr_${arg.expr.name.replace('.', '_')}_${arg.expr.pos.pos}'
-				defer {
+				defer(fn) {
 					g.writeln(';\n\tbuiltin__string_free(&${t});')
 				}
 			}
diff --git a/vlib/v/gen/c/for.v b/vlib/v/gen/c/for.v
@@ -164,7 +164,7 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 			g.type_resolver.update_ct_type(node.val_var, node.val_type)
 			node.scope.update_ct_var_kind(node.val_var, .value_var)
 
-			defer {
+			defer(fn) {
 				g.type_resolver.type_map.delete(node.val_var)
 			}
 		}
@@ -181,7 +181,7 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 				g.type_resolver.update_ct_type(node.key_var, node.key_type)
 				node.scope.update_ct_var_kind(node.key_var, .key_var)
 
-				defer {
+				defer(fn) {
 					g.type_resolver.type_map.delete(node.key_var)
 				}
 			}
diff --git a/vlib/v/gen/c/if.v b/vlib/v/gen/c/if.v
diff --git a/vlib/v/gen/c/infix.v b/vlib/v/gen/c/infix.v
diff --git a/vlib/v/gen/c/match.v b/vlib/v/gen/c/match.v
diff --git a/vlib/v/gen/c/str.v b/vlib/v/gen/c/str.v
diff --git a/vlib/v/gen/c/struct.v b/vlib/v/gen/c/struct.v
diff --git a/vlib/v/gen/golang/golang.v b/vlib/v/gen/golang/golang.v
diff --git a/vlib/v/markused/walker.v b/vlib/v/markused/walker.v
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ fn get_v_build_output(is_verbose bool, is_yes bool, file_path string, user_args`
`67`	`67`	`}`
`68`	`68`	`if result.exit_code == 0 {`
`69`	`69`	`real_generated_file := os.real_path(generated_file)`
`70`		`- defer {`
	`70`	`+ defer(fn) {`
`71`	`71`	`os.rm(generated_file) or {`
`72`	`72`	`if is_verbose {`
`73`	`73`	`elog('> unable to delete generated file: ${err}')`
Original file line number	Diff line number	Diff line change
`@@ -522,7 +522,7 @@ pub fn (s &SSLConn) peer_addr() !net.Addr {`
`522`	`522`	`pub fn (mut s SSLConn) socket_read_into_ptr(buf_ptr &u8, len int) !int {`
`523`	`523`	`mut res := 0`
`524`	`524`	`$if trace_ssl ? {`
`525`		`- defer {`
	`525`	`+ defer(fn) {`
`526`	`526`	`if len > 0 {`
`527`	`527`	eprintln('${@METHOD} res: ${res}: buf_ptr: ${voidptr(buf_ptr):x}, len: ${len}, hex: ${unsafe { buf_ptr.vbytes(len).hex() }} data: `${unsafe { buf_ptr.vstring_with_len(len) }}`')
`528`	`528`	`}`
`@@ -590,7 +590,7 @@ pub fn (mut s SSLConn) read(mut buffer []u8) !int {`
`590`	`590`	`pub fn (mut s SSLConn) write_ptr(bytes &u8, len int) !int {`
`591`	`591`	`mut total_sent := 0`
`592`	`592`	`$if trace_ssl ? {`
`593`		`- defer {`
	`593`	`+ defer(fn) {`
`594`	`594`	`eprintln('${@METHOD} total_sent: ${total_sent}, bytes: ${voidptr(bytes):x}, len: ${len}, hex: ${unsafe { bytes.vbytes(len).hex() }}, data:-=-=-=-\n${unsafe { bytes.vstring_with_len(len) }}\n-=-=-=-')`
`595`	`595`	`}`
`596`	`596`	`}`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ pub fn (s &SSLConn) peer_addr() !net.Addr {`
`270`	`270`	`pub fn (mut s SSLConn) socket_read_into_ptr(buf_ptr &u8, len int) !int {`
`271`	`271`	`mut res := 0`
`272`	`272`	`$if trace_ssl ? {`
`273`		`- defer {`
	`273`	`+ defer(fn) {`
`274`	`274`	`if len > 0 {`
`275`	`275`	eprintln('${@METHOD} res: ${res}: buf_ptr: ${voidptr(buf_ptr):x}, len: ${len}, hex: ${unsafe { buf_ptr.vbytes(len).hex() }} data: `${unsafe { buf_ptr.vstring_with_len(len) }}`')
`276`	`276`	`}`
`@@ -338,7 +338,7 @@ pub fn (mut s SSLConn) read(mut buffer []u8) !int {`
`338`	`338`	`pub fn (mut s SSLConn) write_ptr(bytes &u8, len int) !int {`
`339`	`339`	`mut total_sent := 0`
`340`	`340`	`$if trace_ssl ? {`
`341`		`- defer {`
	`341`	`+ defer(fn) {`
`342`	`342`	`eprintln('${@METHOD} total_sent: ${total_sent}, bytes: ${voidptr(bytes):x}, len: ${len}, hex: ${unsafe { bytes.vbytes(len).hex() }}, data:-=-=-=-\n${unsafe { bytes.vstring_with_len(len) }}\n-=-=-=-')`
`343`	`343`	`}`
`344`	`344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -753,7 +753,7 @@ pub fn executable() string {`
`753`	`753`	`if unsafe { C.sysctl(&mib[0], mib.len, C.NULL, &bufsize, C.NULL, 0) } == 0 {`
`754`	`754`	`if bufsize > max_path_buffer_size {`
`755`	`755`	`pbuf = unsafe { &&u8(malloc(int(bufsize))) }`
`756`		`- defer {`
	`756`	`+ defer(fn) {`
`757`	`757`	`unsafe { free(pbuf) }`
`758`	`758`	`}`
`759`	`759`	`}`
`@@ -856,9 +856,7 @@ pub fn real_path(fpath string) string {`
`856`	`856`	`}`
`857`	`857`	`file := C.CreateFile(fpath_wide, 0x80000000, 1, 0, 3, 0x80, 0)`
`858`	`858`	`if file != voidptr(-1) {`
`859`		`- defer {`
`860`		`- C.CloseHandle(file)`
`861`		`- }`
	`859`	`+ defer { C.CloseHandle(file) }`
`862`	`860`	`// https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew`
`863`	`861`	`final_len := C.GetFinalPathNameByHandleW(file, pu16_fullpath, max_path_buffer_size,`
`864`	`862`	`0)`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ fn (mut p Process) win_spawn_process() int {`
`152`	`152`	`}`
`153`	`153`	`env_block << u16(0)`
`154`	`154`	`creation_flags \|= C.CREATE_UNICODE_ENVIRONMENT`
`155`		`- defer {`
	`155`	`+ defer(fn) {`
`156`	`156`	`unsafe { env_block.free() }`
`157`	`157`	`}`
`158`	`158`	`}`
Original file line number	Diff line number	Diff line change
`@@ -907,7 +907,7 @@ fn (mut t Table) rewrite_already_registered_symbol(typ TypeSymbol, existing_idx`
`907`	`907`	`pub fn (mut t Table) register_sym(sym TypeSymbol) int {`
`908`	`908`	`mut idx := -2`
`909`	`909`	`$if trace_register_sym ? {`
`910`		`- defer {`
	`910`	`+ defer(fn) {`
`911`	`911`	`eprintln('>> register_sym: ${sym.name:-60} \| idx: ${idx}')`
`912`	`912`	`}`
`913`	`913`	`}`
Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {`
`207`	`207`	`mut expr := node.right[i]`
`208`	`208`	`if left is ast.Ident && left.is_mut() && expr is ast.StructInit && expr.is_anon {`
`209`	`209`	`c.anon_struct_should_be_mut = true`
`210`		`- defer {`
	`210`	`+ defer(fn) {`
`211`	`211`	`c.anon_struct_should_be_mut = false`
`212`	`212`	`}`
`213`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3233,7 +3233,7 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {`
`3233`	`3233`	`ast.LambdaExpr {`
`3234`	`3234`	`c.inside_lambda = true`
`3235`	`3235`	`c.table.cur_lambda = unsafe { &node }`
`3236`		`- defer {`
	`3236`	`+ defer(fn) {`
`3237`	`3237`	`c.inside_lambda = false`
`3238`	`3238`	`c.table.cur_lambda = unsafe { nil }`
`3239`	`3239`	`}`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {`
`169`	`169`	`c.type_resolver.update_ct_type(node.val_var, val_type)`
`170`	`170`	`node.scope.update_ct_var_kind(node.val_var, .value_var)`
`171`	`171`
`172`		`- defer {`
	`172`	`+ defer(fn) {`
`173`	`173`	`c.type_resolver.type_map.delete(node.val_var)`
`174`	`174`	`}`
`175`	`175`	`}`
`@@ -194,7 +194,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {`
`194`	`194`	`c.type_resolver.update_ct_type(node.key_var, key_type)`
`195`	`195`	`node.scope.update_ct_var_kind(node.key_var, .key_var)`
`196`	`196`
`197`		`- defer {`
	`197`	`+ defer(fn) {`
`198`	`198`	`c.type_resolver.type_map.delete(node.key_var)`
`199`	`199`	`}`
`200`	`200`	`}`
`@@ -211,7 +211,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {`
`211`	`211`	`c.type_resolver.update_ct_type(node.val_var, value_type)`
`212`	`212`	`node.scope.update_ct_var_kind(node.val_var, .value_var)`
`213`	`213`
`214`		`- defer {`
	`214`	`+ defer(fn) {`
`215`	`215`	`c.type_resolver.type_map.delete(node.val_var)`
`216`	`216`	`}`
`217`	`217`	`}`
`@@ -236,7 +236,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {`
`236`	`236`	`c.type_resolver.update_ct_type(node.key_var, key_type)`
`237`	`237`	`node.scope.update_ct_var_kind(node.key_var, .key_var)`
`238`	`238`
`239`		`- defer {`
	`239`	`+ defer(fn) {`
`240`	`240`	`c.type_resolver.type_map.delete(node.key_var)`
`241`	`241`	`}`
`242`	`242`	`}`
`@@ -300,7 +300,7 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {`
`300`	`300`	`c.type_resolver.update_ct_type(node.val_var, value_type)`
`301`	`301`	`node.scope.update_ct_var_kind(node.val_var, .value_var)`
`302`	`302`
`303`		`- defer {`
	`303`	`+ defer(fn) {`
`304`	`304`	`c.type_resolver.type_map.delete(node.val_var)`
`305`	`305`	`}`
`306`	`306`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {`
`77`	`77`	`former_expected_type := c.expected_type`
`78`	`78`	`if node_is_expr {`
`79`	`79`	`c.expected_expr_type = c.expected_type`
`80`		`- defer {`
	`80`	`+ defer(fn) {`
`81`	`81`	`c.expected_expr_type = ast.void_type`
`82`	`82`	`}`
`83`	`83`	`}`