cgen: fix p := unsafe{ &m[key] or { nil } } (fix #25387) (#25408)

Author: spytheman

vlib/v/gen/c/cgen.v

@@ -168,6 +168,7 @@ mut:
 	last_tmp_call_var         []string
 	last_if_option_type       ast.Type // stores the expected if type on nested if expr
 	loop_depth                int
+	unsafe_level              int
 	ternary_names             map[string]string
 	ternary_level_names       map[string][]string
 	arraymap_set_pos          int      // map or array set value position
@@ -2523,6 +2524,10 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 		}
 		ast.Block {
 			g.write_v_source_line_info_stmt(node)
+			if node.is_unsafe {
+				g.unsafe_level++
+			}
+
 			if !node.is_unsafe {
 				g.writeln('{')
 			} else {
@@ -2534,6 +2539,9 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			}
 			g.stmts(node.stmts)
 			g.writeln('}')
+			if node.is_unsafe {
+				g.unsafe_level--
+			}
 		}
 		ast.AssignStmt {
 			g.write_v_source_line_info_stmt(node)
@@ -4084,7 +4092,9 @@ fn (mut g Gen) expr(node_ ast.Expr) {
 			g.typeof_expr(node)
 		}
 		ast.UnsafeExpr {
+			g.unsafe_level++
 			g.expr(node.expr)
+			g.unsafe_level--
 		}
 	}
 	g.discard_or_result = old_discard_or_result

vlib/v/gen/c/index.v

@@ -543,6 +543,18 @@ fn (mut g Gen) index_of_map(node ast.IndexExpr, sym ast.TypeSymbol) {
 		}
 		if gen_or {
 			g.writeln(';')
+			if g.unsafe_level > 0 && !node.is_option && !node.is_setter
+				&& node.or_expr.kind == .block && node.or_expr.stmts.len == 1 {
+				last_stmt := node.or_expr.stmts[0]
+				if last_stmt is ast.ExprStmt && last_stmt.typ.is_any_kind_of_pointer() {
+					// handle the case of `p := unsafe{ &m[key] or { nil } }` directly, without an intermediate option + copies etc:
+					g.write('if (!${tmp_opt_ptr}) { ${tmp_opt_ptr} = ')
+					g.expr(last_stmt.expr)
+					g.write('; }')
+					g.write('\n${cur_line}(*${tmp_opt_ptr})')
+					return
+				}
+			}
 			opt_val_type := g.styp(val_type.set_flag(.option))
 			g.writeln('${opt_val_type} ${tmp_opt} = {0};')
 			g.writeln('if (${tmp_opt_ptr}) {')

vlib/v/tests/builtin_maps/unsafe_pointers_to_map_values_test.v

@@ -0,0 +1,41 @@
+struct MyObject {
+mut:
+	x int
+	s string
+}
+
+struct Abc {
+mut:
+	mymap map[string]MyObject
+}
+
+fn test_codegen_for_unsafe_pointers_to_map_values() {
+	mut inst := Abc{}
+	inst.mymap['abc'] = MyObject{123, 'abc'}
+	inst.mymap['def'] = MyObject{456, 'def'}
+	dump(inst)
+
+	mut p1 := unsafe { &inst.mymap['abc'] or { nil } }
+	p2 := unsafe { &inst.mymap['def'] or { nil } }
+	p3 := unsafe { &inst.mymap['zzz_unknown'] or { nil } }
+	assert typeof(p1).name == '&MyObject'
+	assert typeof(p2).name == '&MyObject'
+	assert typeof(p3).name == '&MyObject'
+	dump(p1)
+	dump(p2)
+	dump(p3)
+	assert p1 != unsafe { nil }
+	assert p2 != unsafe { nil }
+	assert p3 == unsafe { nil }
+	assert p1.x == 123
+	assert p1.s == 'abc'
+	assert p2.x == 456
+	assert p2.s == 'def'
+	// check that `p1` points to the exact same instance that is stored in the map:
+	assert inst.mymap['abc'].x == 123
+	assert inst.mymap['abc'].s == 'abc'
+	p1.x = 999
+	p1.s = 'xyz'
+	assert inst.mymap['abc'].x == 999
+	assert inst.mymap['abc'].s == 'xyz'
+}