cgen: fixes

Author: medvednikov

vlib/v/gen/c/assign.v

@@ -75,11 +75,6 @@ fn (mut g Gen) expr_with_opt_or_block(expr ast.Expr, expr_typ ast.Type, var_expr
 	if gen_or {
 		old_inside_opt_or_res := g.inside_opt_or_res
 		g.inside_opt_or_res = true
-		g.expr_with_cast(expr, expr_typ, ret_typ)
-		if in_heap {
-			g.write('))')
-		}
-		g.writeln(';')
 		expr_var := if expr is ast.Ident && expr.kind == .constant {
 			g.c_const_name(expr.name)
 		} else if expr is ast.Ident && expr.is_auto_heap() {
@@ -88,6 +83,20 @@ fn (mut g Gen) expr_with_opt_or_block(expr ast.Expr, expr_typ ast.Type, var_expr
 			'${expr}'
 		}
 		dot_or_ptr := if !expr_typ.has_flag(.option_mut_param_t) { '.' } else { '-> ' }
+		mut heap_line := ''
+		if in_heap {
+			// When the variable needs heap allocation, the caller has already
+			// written the partial line `TYPE *var = HEAP(TYPE, (`.
+			// We must NOT access the option's .data inside the HEAP macro
+			// before checking the state, because the option may be `none`.
+			// Pull back the partial line, emit the state check first, then
+			// write the assignment with data access after the check.
+			heap_line = g.go_before_last_stmt()
+			g.empty_line = true
+		} else {
+			g.expr_with_cast(expr, expr_typ, ret_typ)
+			g.writeln(';')
+		}
 		g.writeln('if (${c_name(expr_var)}${dot_or_ptr}state != 0) { // assign')
 		if expr is ast.Ident && expr.or_expr.kind == .propagate_option {
 			g.writeln('\tbuiltin__panic_option_not_set(_S("none"));')
@@ -123,6 +132,13 @@ fn (mut g Gen) expr_with_opt_or_block(expr ast.Expr, expr_typ ast.Type, var_expr
 			}
 		}
 		g.writeln('}')
+		if in_heap {
+			// Now that the state has been checked (and we haven't returned/panicked),
+			// it is safe to access .data and do the heap allocation.
+			g.write(heap_line)
+			g.expr_with_cast(expr, expr_typ, ret_typ)
+			g.writeln('));')
+		}
 		g.inside_opt_or_res = old_inside_opt_or_res
 	} else {
 		g.expr_with_opt(expr, expr_typ, ret_typ)

vlib/v/gen/c/auto_str_methods.v

@@ -1135,7 +1135,7 @@ fn (mut g Gen) gen_str_for_struct(info ast.Struct, lang ast.Language, styp strin
 		} else if ftyp_noshared.is_ptr() {
 			// reference types can be "nil"
 			if ftyp_noshared.has_flag(.option) {
-				funcprefix += 'builtin__isnil(&${it_field_name}) || builtin__isnil(&${it_field_name}.data)'
+				funcprefix += '${it_field_name}.state != 0'
 			} else {
 				funcprefix += 'builtin__isnil(${it_field_name})'
 			}

vlib/v/gen/c/if.v

@@ -117,6 +117,21 @@ fn (mut g Gen) need_tmp_var_in_expr(expr ast.Expr) bool {
 			if g.need_tmp_var_in_expr(expr.right) {
 				return true
 			}
+			// struct pointer equality comparisons may hoist temp vars
+			// (via gen_struct_pointer_eq_op) which breaks short-circuit
+			// evaluation when used on the right side of `&&` after an
+			// `is` check. Detect this so that infix_expr_and_or_op uses
+			// its safe short-circuit pattern instead.
+			if expr.op in [.eq, .ne] {
+				if (expr.left_type.is_ptr() && !expr.left.is_lvalue())
+					|| (expr.right_type.is_ptr() && !expr.right.is_lvalue()) {
+					left_sym := g.table.sym(expr.left_type)
+					right_sym := g.table.sym(expr.right_type)
+					if left_sym.kind == .struct || right_sym.kind == .struct {
+						return true
+					}
+				}
+			}
 		}
 		ast.MapInit {
 			for key in expr.keys {

vlib/v/gen/c/infix.v

@@ -490,11 +490,16 @@ fn (mut g Gen) infix_expr_eq_op(node ast.InfixExpr) {
 }
 
 fn (mut g Gen) gen_struct_pointer_eq_op(node ast.InfixExpr, left_type ast.Type, right_type ast.Type, ptr_typ string) {
+	// When inside a short-circuit `&&` condition (infix_left_var_name is set),
+	// do not hoist temp vars before the containing statement, as that would
+	// evaluate expressions (e.g. as-casts from smartcasts) before the
+	// short-circuit check has run. Instead, use inline expressions.
+	inside_and_rhs := g.infix_left_var_name.len > 0
 	mut stmt_str := ''
 	mut restore_stmt := false
 	mut left_expr := ''
 	mut right_expr := ''
-	if left_type.is_ptr() && !node.left.is_lvalue() {
+	if left_type.is_ptr() && !node.left.is_lvalue() && !inside_and_rhs {
 		if !restore_stmt {
 			stmt_str = g.go_before_last_stmt().trim_space()
 			g.empty_line = true
@@ -506,7 +511,7 @@ fn (mut g Gen) gen_struct_pointer_eq_op(node ast.InfixExpr, left_type ast.Type,
 	} else {
 		left_expr = g.expr_string(node.left)
 	}
-	if right_type.is_ptr() && !node.right.is_lvalue() {
+	if right_type.is_ptr() && !node.right.is_lvalue() && !inside_and_rhs {
 		if !restore_stmt {
 			stmt_str = g.go_before_last_stmt().trim_space()
 			g.empty_line = true

vlib/v/gen/c/spawn_and_go.v

@@ -127,7 +127,34 @@ fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
 		g.expr(arg.expr)
 		g.writeln(';')
 	}
-	call_ret_type := g.unwrap_generic(node.call_expr.return_type)
+	call_ret_type := if expr.is_fn_var && g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0
+		&& g.cur_fn.generic_names.len > 0 {
+		// In generic contexts, node.call_expr.return_type may be stale from
+		// a previous instantiation. Look up the original fn param from the table
+		// and resolve through convert_generic_type.
+		mut resolved_ret := g.unwrap_generic(node.call_expr.return_type)
+		cur_fn_name := g.cur_fn.fkey()
+		orig_fn := g.table.find_fn(cur_fn_name) or { ast.Fn{} }
+		for param in orig_fn.params {
+			if param.name == expr.name {
+				if param.typ.has_flag(.generic) || g.type_has_unresolved_generic_parts(param.typ) {
+					mut muttable := unsafe { &ast.Table(g.table) }
+					if resolved_type := muttable.convert_generic_type(param.typ, orig_fn.generic_names,
+						g.cur_concrete_types)
+					{
+						fn_sym := g.table.sym(resolved_type)
+						if fn_sym.info is ast.FnType {
+							resolved_ret = fn_sym.info.func.return_type
+						}
+					}
+				}
+				break
+			}
+		}
+		resolved_ret
+	} else {
+		g.unwrap_generic(node.call_expr.return_type)
+	}
 	s_ret_typ := g.styp(g.unwrap_generic(call_ret_type))
 	if g.pref.os == .windows && call_ret_type != ast.void_type {
 		g.writeln('${arg_tmp_var}->ret_ptr = (void *) builtin___v_malloc(sizeof(${s_ret_typ}));')
@@ -191,6 +218,7 @@ fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
 		g.type_definitions.writeln('\ntypedef struct ${wrapper_struct_name} {')
 		mut fn_var := ''
 		mut wrapper_return_type := call_ret_type
+		mut resolved_fn_params := []ast.Param{}
 		if node.call_expr.is_fn_var {
 			mut fn_var_type := node.call_expr.fn_var_type
 			// In generic contexts, fn_var_type may be stale from the last checker pass.
@@ -217,6 +245,7 @@ fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
 			}
 			fn_sym := g.table.sym(fn_var_type)
 			info := fn_sym.info as ast.FnType
+			resolved_fn_params = info.func.params.clone()
 			wrapper_return_type = info.func.return_type
 			fn_var = g.fn_var_signature(ast.void_type, wrapper_return_type, info.func.params.map(it.typ),
 				'fn')
@@ -278,16 +307,20 @@ fn (mut g Gen) spawn_and_go_expr(node ast.SpawnExpr, mode SpawnGoMode) {
 		need_return_ptr := g.pref.os == .windows && wrapper_return_type != ast.void_type
 		for i, arg in expr.args {
 			mut arg_typ := arg.typ
-			// For AnonFn calls in generic contexts, use the declared parameter
-			// types instead of argument expression types, since the AST arg types
-			// may be stale from a previous generic instantiation.
+			// For fn var and AnonFn calls in generic contexts, use the declared
+			// parameter types instead of argument expression types, since the
+			// AST arg types may be stale from a previous generic instantiation.
 			if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
 				if expr.left is ast.AnonFn {
 					anon := expr.left as ast.AnonFn
 					f := anon.decl
 					if i < f.params.len {
 						arg_typ = g.unwrap_generic(f.params[i].typ)
 					}
+				} else if expr.is_fn_var && resolved_fn_params.len > 0 {
+					if i < resolved_fn_params.len {
+						arg_typ = resolved_fn_params[i].typ
+					}
 				} else {
 					resolved_arg_typ := g.unwrap_generic(arg_typ)
 					if resolved_arg_typ != 0 {