checker: keep map-copy guard for option-map or-unwraps (#27867)

vlib/v/checker/assign.v

@@ -28,6 +28,20 @@ fn assign_expr_is_auto_deref(expr ast.Expr) bool {
 	return expr.is_auto_deref_var()
 }
 
+// assign_or_unwrap_source_is_immutable conservatively reports whether the source
+// of an `or {}` unwrap can never be mutated later (so a copy of its map cannot
+// observe a later mutation of the original). Only the plainly-immutable roots are
+// recognised; anything unknown returns false, keeping the map-copy guard.
+fn assign_or_unwrap_source_is_immutable(expr ast.Expr) bool {
+	return match expr {
+		ast.Ident { !expr.is_mut() }
+		ast.SelectorExpr { assign_or_unwrap_source_is_immutable(expr.expr) }
+		ast.IndexExpr { assign_or_unwrap_source_is_immutable(expr.left) }
+		ast.ParExpr { assign_or_unwrap_source_is_immutable(expr.expr) }
+		else { false }
+	}
+}
+
 fn (c &Checker) auto_deref_source_type_is_pointer(expr ast.Expr) bool {
 	if expr !is ast.Ident || c.table.cur_fn == unsafe { nil } || !expr.is_auto_deref_var() {
 		return false
@@ -886,8 +900,37 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 		} else {
 			right.is_lvalue()
 		}
+		// `x := opt_map or { ... }` unwraps an option/result into a new immutable
+		// variable, so `x` can never become a mutable alias of the underlying map
+		// and the shallow copy is safe. This mirrors how V already accepts the
+		// equivalent immutable `x := opt_array_field or { ... }`. Several things
+		// must hold for the copy to be safe, otherwise the guard is kept so
+		// aliasing still requires a `clone`/`move`:
+		//   - the destination is a new immutable variable (a mutable `mut x := ...`
+		//     or a reassignment `x = ...` could still mutate through `x`);
+		//   - the `or` actually clears the option/result — for `map[K]?map[...]`,
+		//     `v := m[k] or { none }` keeps the option-map type, so `v` is still an
+		//     option handle aliasing the map in `m`;
+		//   - the unwrapped source itself is immutable — otherwise a later mutation
+		//     of the source (e.g. `mut opt := ...; x := opt or { ... }; opt?[k] = v`)
+		//     would be observed through `x`.
+		// See vlang/v issue #27867.
+		mut right_is_immutable_or_unwrap := false
+		if node.op == .decl_assign && left is ast.Ident && !left.is_mut
+			&& !right_type.has_flag(.option) && !right_type.has_flag(.result) {
+			unwrapped_right := right.remove_par()
+			has_or_block := match unwrapped_right {
+				ast.Ident { unwrapped_right.or_expr.kind != .absent }
+				ast.IndexExpr { unwrapped_right.or_expr.kind != .absent }
+				ast.SelectorExpr { unwrapped_right.or_block.kind != .absent }
+				else { false }
+			}
+
+			right_is_immutable_or_unwrap = has_or_block
+				&& assign_or_unwrap_source_is_immutable(unwrapped_right)
+		}
 		if left_sym.kind == .map && is_assign && right_sym.kind == .map && !c.inside_unsafe
-			&& !left.is_blank_ident() && right_is_lvalue
+			&& !left.is_blank_ident() && right_is_lvalue && !right_is_immutable_or_unwrap
 			&& (!right_type.is_ptr() || (right is ast.Ident && assign_expr_is_auto_deref(right))) {
 			// Do not allow `a = b`
 			c.error('cannot copy map: call `move` or `clone` method (or use a reference)',

vlib/v/checker/tests/option_map_or_unwrap_mut_alias_err.out

@@ -0,0 +1,14 @@
+vlib/v/checker/tests/option_map_or_unwrap_mut_alias_err.vv:14:17: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   12 |         'x': 1
+   13 |     }]
+   14 |     mut a := xs[0] or { panic('missing') }
+      |                    ~~~~~~~~~~~~~~~~~~~~~~~
+   15 |     a['x'] = 2
+   16 |
+vlib/v/checker/tests/option_map_or_unwrap_mut_alias_err.vv:22:13: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   20 |         }
+   21 |     }
+   22 |     mut b := c.translations or { panic('missing') }
+      |                ~~~~~~~~~~~~
+   23 |     b['x'] = 2
+   24 |

vlib/v/checker/tests/option_map_or_unwrap_mut_alias_err.vv

@@ -0,0 +1,29 @@
+// Or-unwrapping an option map into a *mutable* destination would let the new
+// variable alias the container/field storage, so it must still require an
+// explicit `clone`/`move`. See vlang/v issue #27867 (the immutable
+// `x := opt_map or { ... }` form is allowed, the mutable form is not).
+struct Category {
+mut:
+	translations ?map[string]int
+}
+
+fn main() {
+	mut xs := [{
+		'x': 1
+	}]
+	mut a := xs[0] or { panic('missing') }
+	a['x'] = 2
+
+	mut c := Category{
+		translations: {
+			'x': 1
+		}
+	}
+	mut b := c.translations or { panic('missing') }
+	b['x'] = 2
+
+	println(xs)
+	println(c)
+	println(a)
+	println(b)
+}

vlib/v/checker/tests/option_map_or_unwrap_mut_source_err.out

@@ -0,0 +1,21 @@
+vlib/v/checker/tests/option_map_or_unwrap_mut_source_err.vv:17:7: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   15 |         'x': 1
+   16 |     }
+   17 |     a := opt or { panic('missing') }
+      |          ~~~
+   18 | 
+   19 |     mut c := Category{
+vlib/v/checker/tests/option_map_or_unwrap_mut_source_err.vv:24:9: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   22 |         }
+   23 |     }
+   24 |     b := c.translations or { panic('missing') }
+      |            ~~~~~~~~~~~~
+   25 | 
+   26 |     inner := {
+vlib/v/checker/tests/option_map_or_unwrap_mut_source_err.vv:32:14: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   30 |         'a': ?map[string]int(inner)
+   31 |     }
+   32 |     d := m['a'] or { panic('missing') }
+      |                 ~~~~~~~~~~~~~~~~~~~~~~~
+   33 | 
+   34 |     println(a)

vlib/v/checker/tests/option_map_or_unwrap_mut_source_err.vv

@@ -0,0 +1,37 @@
+// Or-unwrapping an option map into an immutable local is only safe when the
+// *source* can never be mutated later. If the source (variable, field, or index)
+// is mutable, the immutable local still aliases the same map storage and would
+// observe a later mutation, so the map-copy guard must stay. See vlang/v issue
+// #27867 (only immutable-source unwraps like `c := Category{}; x := c.f or {...}`
+// are exempted).
+struct Category {
+mut:
+	translations ?map[string]int
+}
+
+fn main() {
+	mut opt := ?map[string]int(none)
+	opt = {
+		'x': 1
+	}
+	a := opt or { panic('missing') }
+
+	mut c := Category{
+		translations: {
+			'x': 1
+		}
+	}
+	b := c.translations or { panic('missing') }
+
+	inner := {
+		'x': 1
+	}
+	mut m := {
+		'a': ?map[string]int(inner)
+	}
+	d := m['a'] or { panic('missing') }
+
+	println(a)
+	println(b)
+	println(d)
+}

vlib/v/checker/tests/option_map_or_unwrap_preserves_option_err.out

@@ -0,0 +1,7 @@
+vlib/v/checker/tests/option_map_or_unwrap_preserves_option_err.vv:14:14: error: cannot copy map: call `move` or `clone` method (or use a reference)
+   12 |         'a': ?map[string]int(inner)
+   13 |     }
+   14 |     v := m['a'] or { none }
+      |                 ~~~~~~~~~~~
+   15 |     println(v)
+   16 | }

vlib/v/checker/tests/option_map_or_unwrap_preserves_option_err.vv

@@ -0,0 +1,16 @@
+// For `map[K]?map[...]`, an `or` block that returns `none` (or another `?map`)
+// does NOT clear the option: `v := m[k] or { none }` keeps the option-map type,
+// so `v` is still an option handle that aliases the map stored in `m`. The
+// map-copy guard must stay in that case, even though the destination is an
+// immutable declaration. See vlang/v issue #27867 (only the option-clearing
+// form `m[k] or { panic(...) }` is exempted).
+fn main() {
+	inner := {
+		'x': 1
+	}
+	m := {
+		'a': ?map[string]int(inner)
+	}
+	v := m['a'] or { none }
+	println(v)
+}

vlib/v/tests/options/option_map_field_or_unwrap_test.v

@@ -0,0 +1,70 @@
+// Regression test for https://github.com/vlang/v/issues/27867
+// or-unwrapping an option map (struct field, variable, index, parenthesized)
+// into an immutable variable used to fail with
+// `cannot copy map: call move or clone method (or use a reference)`.
+// The mutable form (`mut x := m or { ... }`) still errors on purpose, see
+// vlib/v/checker/tests/option_map_or_unwrap_mut_alias_err.vv.
+struct Translation {
+	title string
+}
+
+struct Category {
+	title        string
+	translations ?map[string]Translation
+}
+
+fn test_option_map_field_or_unwrap() {
+	c := Category{
+		translations: {
+			'en': Translation{
+				title: 'Hello'
+			}
+		}
+	}
+	translations := c.translations or { panic('expected') }
+	assert translations['en'].title == 'Hello'
+}
+
+fn test_option_map_field_or_unwrap_none() {
+	c := Category{}
+	translations := c.translations or {
+		map[string]Translation{}
+	}
+
+	assert translations.len == 0
+}
+
+fn get_option_map() ?map[string]int {
+	return {
+		'a': 1
+	}
+}
+
+fn test_option_map_var_or_unwrap() {
+	x := get_option_map()
+	y := x or { panic('expected') }
+	assert y['a'] == 1
+}
+
+fn test_option_map_index_or_unwrap() {
+	inner_map := {
+		'b': 2
+	}
+	m := {
+		'a': inner_map
+	}
+	inner := m['a'] or { panic('expected') }
+	assert inner['b'] == 2
+}
+
+fn test_option_map_field_paren_or_unwrap() {
+	c := Category{
+		translations: {
+			'en': Translation{
+				title: 'Hello'
+			}
+		}
+	}
+	translations := (c.translations or { panic('expected') })
+	assert translations['en'].title == 'Hello'
+}