v3: accept bare generic struct literals where a concrete instance is expected

`fn make() Box[int] { return Box{...} }` (and the `&Box{...}` heap form, and
bare literals passed/assigned where a concrete generic instance is expected)
previously failed the checker with `cannot return Box as Box[int]`, because the
return/assignment path resolves the value through `resolve_expr(expected)` and
that had no `struct_init` case — a bare `Box{...}` stayed the unspecialised base
`Box`, incompatible with `Box[int]`.

resolve_expr now adopts a matching concrete expected instance for a bare generic
struct literal (`bare_generic_literal_adopts`: base short-names match and the
base is a known generic struct), covering both the value and `&` heap forms. The
cgen side already materialises the concrete `Box_int` / `(Box_int*)memdup(...)`
in return position via the `in_return`/`cur_fn_ret` fallback.

To avoid silently adopting an unrelated literal (and emitting broken C), each
named field initializer is checked against the instantiation
(`generic_literal_fields_compatible`, substituting the type params); a definite
mismatch like `Box{v: 'str'}` for `Box[int]` is rejected as a type error rather
than reaching the C compiler, while valid coercions (`Vec[f64]{x: 1}`) are kept.

Adds regression tests (value/heap/multi-param adoption; field mismatch rejected).
Verified: matches V1, self-host v5 == v6 byte-identical, no vlib/v3/tests
regressions, doka still builds and renders.

Author: medvednikov

vlib/v3/tests/type_checker_errors_test.v

@@ -439,3 +439,23 @@ fn test_pr_review_codegen_batch_three() {
 		"struct G {\n\tn int\n}\nfn (g G) make() ?string {\n\treturn 'hi'\n}\nfn run(cb fn () ?string) {\n\ts := cb() or { 'none' }\n\tprintln(s)\n}\nfn main() {\n\tg := G{\n\t\tn: 1\n\t}\n\trun(g.make)\n}\n")
 	assert mv == 'hi'
 }
+
+// Regression tests: a bare generic struct literal adopts a matching concrete
+// expected instance (value and heap), and a field-type mismatch is rejected.
+fn test_bare_generic_literal_adopts_expected_instance() {
+	v3_bin := build_v3()
+	val := run_good(v3_bin, 'good_bare_generic_literal_return',
+		'struct Box[T] {\n\tv T\n}\nfn make() Box[int] {\n\treturn Box{\n\t\tv: 7\n\t}\n}\nfn main() {\n\tprintln(int_str(make().v))\n}\n')
+	assert val == '7'
+	heap := run_good(v3_bin, 'good_bare_generic_literal_heap_return',
+		'struct Box[T] {\n\tv T\n}\nfn make() &Box[int] {\n\treturn &Box{\n\t\tv: 9\n\t}\n}\nfn main() {\n\tprintln(int_str(make().v))\n}\n')
+	assert heap == '9'
+	pair := run_good(v3_bin, 'good_bare_generic_literal_multi_param',
+		"struct Pair[L, R] {\n\tl L\n\tr R\n}\nfn make() Pair[string, int] {\n\treturn Pair{\n\t\tl: 'hi'\n\t\tr: 5\n\t}\n}\nfn main() {\n\tp := make()\n\tprintln(p.l)\n\tprintln(int_str(p.r))\n}\n")
+	assert pair == 'hi\n5'
+	// A field whose type does not match the concrete instantiation is rejected by the
+	// checker (rather than adopting the type and emitting broken C).
+	run_bad(v3_bin, 'bad_bare_generic_literal_field_mismatch',
+		"struct Box[T] {\n\tv T\n}\nfn make() Box[int] {\n\treturn Box{\n\t\tv: 'str'\n\t}\n}\nfn main() {\n\t_ := make()\n}\n",
+		'cannot return `Box` as `Box[int]`')
+}

vlib/v3/types/checker.v

@@ -3484,6 +3484,70 @@ fn (tc &TypeChecker) is_concrete_generic_instance(name string) bool {
 	return tc.generic_args_are_concrete(args)
 }
 
+// bare_generic_literal_adopts reports whether a struct literal written as the bare
+// generic base (`Box{...}`, no type args) should adopt the concrete `expected`
+// instance (`Box[int]`, optionally behind a pointer). The base short-names must match
+// and the base must be a known generic struct, so a non-generic same-named struct is
+// left to ordinary checking.
+fn (tc &TypeChecker) bare_generic_literal_adopts(lit_value string, expected Type) bool {
+	if lit_value.len == 0 || lit_value.contains('[') {
+		return false
+	}
+	e_base, _, e_ok := generic_type_application_parts(unwrap_pointer(expected).name())
+	if !e_ok || e_base.all_after_last('.') != lit_value.all_after_last('.') {
+		return false
+	}
+	return e_base in tc.struct_generic_params
+		|| e_base.all_after_last('.') in tc.struct_generic_params
+}
+
+// generic_literal_fields_compatible checks a bare generic struct literal's named
+// field initializers against the expected concrete instantiation (`Box[int]`),
+// substituting the struct's type parameters into each field's declared type. It
+// returns false only on a *definite* mismatch (e.g. `Box{v: 'str'}` for `Box[int]`),
+// so a clearly-unrelated literal yields a clean checker error instead of adopting the
+// type and emitting broken C; unresolvable fields stay lenient.
+fn (mut tc TypeChecker) generic_literal_fields_compatible(node flat.Node, expected Type) bool {
+	e_base, e_args, e_ok := generic_type_application_parts(unwrap_pointer(expected).name())
+	if !e_ok {
+		return true
+	}
+	params := tc.struct_generic_params[e_base] or {
+		tc.struct_generic_params[e_base.all_after_last('.')] or { return true }
+	}
+	if params.len != e_args.len {
+		return true
+	}
+	fields := tc.structs[e_base] or { tc.structs[e_base.all_after_last('.')] or { return true } }
+	for i in 0 .. node.children_count {
+		fi := tc.a.child_node(&node, i)
+		if fi.kind != .field_init || fi.value.len == 0 || fi.children_count == 0 {
+			continue
+		}
+		mut decl_typ := Type(void_)
+		mut found := false
+		for f in fields {
+			if f.name == fi.value {
+				decl_typ = f.typ
+				found = true
+				break
+			}
+		}
+		if !found {
+			continue
+		}
+		sub := tc.substitute_generic_type(decl_typ, e_args, params)
+		if sub is Unknown || sub is Void {
+			continue
+		}
+		actual := tc.resolve_expr(tc.a.child(fi, 0), sub)
+		if !tc.receiver_compatible(actual, sub) {
+			return false
+		}
+	}
+	return true
+}
+
 // strip_generic_args_name returns the base name of a generic instance type
 // (`Box[int]` -> `Box`); array/map types (leading `[`) yield the name unchanged.
 fn strip_generic_args_name(name string) string {
@@ -4736,6 +4800,23 @@ fn (mut tc TypeChecker) resolve_expr(id flat.NodeId, expected Type) Type {
 			'unknown enum field `${node.value}` for `${expected.name}`', id)
 		return Type(int_)
 	}
+	// A bare generic struct literal (`Box{...}` / `&Box{...}`) adopts a matching concrete
+	// expected instance (`Box[int]` / `&Box[int]`), so `fn make() Box[int] { return
+	// Box{...} }` and bare literals passed/assigned where a concrete instance is expected
+	// type-check and carry the concrete type into codegen.
+	if node.kind == .struct_init && tc.bare_generic_literal_adopts(node.value, expected)
+		&& tc.generic_literal_fields_compatible(node, expected) {
+		tc.register_synth_type(id, expected_raw)
+		return expected_raw
+	}
+	if node.kind == .prefix && node.op == .amp && node.children_count == 1 && expected is Pointer {
+		child := tc.a.nodes[int(tc.a.child(&node, 0))]
+		if child.kind == .struct_init && tc.bare_generic_literal_adopts(child.value, expected)
+			&& tc.generic_literal_fields_compatible(child, expected) {
+			tc.register_synth_type(id, expected_raw)
+			return expected_raw
+		}
+	}
 	if node.kind == .array_literal {
 		mut elem_expected := Type(void_)
 		mut expected_is_array := false