Merge branch 'vlang:master' into http3-quic-h3-client

Author: quaesitor-scientiam

vlib/v3/driver/driver.v

@@ -2471,6 +2471,38 @@ fn prepare_v3_cache_external_inputs(mut state V3ModuleCacheState, a &flat.FlatAs
 	return !has_untracked_c_include && can_scope_static_inputs && can_extract_native_types
 }
 
+fn ast_has_native_source_include(a &flat.FlatAst) bool {
+	for node in a.nodes {
+		if node.kind != .directive
+			|| node.value !in ['include', 'insert', 'preinclude', 'postinclude'] {
+			continue
+		}
+		path := node.typ.trim_space().trim('"')
+		if path.ends_with('.c') || path.ends_with('.m') || path.ends_with('.mm') {
+			return true
+		}
+	}
+	return false
+}
+
+fn register_native_source_typedefs(mut tc types.TypeChecker, state &V3ModuleCacheState) {
+	for roots in state.module_native_roots.values() {
+		for path in roots {
+			source := os.read_file(path) or { continue }
+			for name, present in modulecache.c_source_typedef_identifiers(source) {
+				if !present || name.len == 0 {
+					continue
+				}
+				c_name := 'C.${name}'
+				if c_name !in tc.structs {
+					tc.structs[c_name] = []types.StructField{}
+				}
+				tc.c_typedef_structs[c_name] = true
+			}
+		}
+	}
+}
+
 fn cache_c_compiler_predefined_macros(flags []string, ccompiler string, target pref.Target, native_inputs_language string) (map[string]string, bool) {
 	path := os.join_path(os.vtmp_dir(), 'v3_compiler_macros_${tempname.unique_token()}.c')
 	defer {
@@ -7882,6 +7914,12 @@ pub fn run(args []string) {
 			exit(1)
 		}
 	}
+	// Source includes can introduce typedef structs used by V declarations and
+	// literals before Cgen sees the included translation unit. Resolve those rare
+	// inputs before checking so the type is available to semantic lookup.
+	if !cache_state.external_inputs_ready && ast_has_native_source_include(a) {
+		_ = prepare_v3_cache_external_inputs(mut cache_state, a, prefs, user_files, cache_c_flags)
+	}
 
 	// Type-collect + check BEFORE transform, so the transformer is type-aware
 	// (like v2: check runs before transform). The transformer reads cached
@@ -7929,6 +7967,7 @@ pub fn run(args []string) {
 		}
 		mut cvsw := time.new_stopwatch()
 		pre_tc.collect(a)
+		register_native_source_typedefs(mut pre_tc, &cache_state)
 		if translated_mode {
 			for file in user_files {
 				pre_tc.translated_files[file] = true

vlib/v3/gen/c/array.v

@@ -842,7 +842,7 @@ fn (mut g FlatGen) gen_array_method_call_fallback(node flat.Node, mname string,
 // gen_array_pointers_expr emits `array.pointers()` without compiling the erased
 // raw `array` builtin body, which has no concrete element type in v3 Cgen.
 fn (mut g FlatGen) gen_array_pointers_expr(base_id flat.NodeId, is_ptr bool) {
-	base_type := types.unwrap_pointer(g.tc.resolve_type(base_id))
+	base_type := types.unwrap_pointer(g.usable_expr_type(base_id))
 	if fixed := array_fixed_type(base_type) {
 		g.gen_fixed_array_pointers_expr(base_id, is_ptr, fixed)
 		return

vlib/v3/gen/c/fn.v

@@ -5637,10 +5637,11 @@ fn (mut g FlatGen) gen_call(id flat.NodeId, node flat.Node) {
 			return
 		}
 	}
-	if target_name == 'array.pointers' || fn_name == 'array.pointers' {
+	if target_name in ['array.pointers', '__v3_fixed_array_pointers']
+		|| fn_name in ['array.pointers', '__v3_fixed_array_pointers'] {
 		if node.children_count > 1 {
 			arg_id := g.a.child(&node, 1)
-			g.gen_array_pointers_expr(arg_id, g.tc.resolve_type(arg_id) is types.Pointer)
+			g.gen_array_pointers_expr(arg_id, g.usable_expr_type(arg_id) is types.Pointer)
 		} else {
 			g.write('array_new(sizeof(voidptr), 0, 0)')
 		}
@@ -9988,6 +9989,9 @@ fn (mut g FlatGen) optional_type_name_for_expr(id flat.NodeId, typ types.Type) s
 	}
 	if int(id) >= 0 && int(id) < g.a.nodes.len {
 		node := g.a.nodes[int(id)]
+		if g.cur_fn_is_specialized && node.kind == .struct_init && type_is_optional_result(typ) {
+			return g.concrete_optional_type_name(typ)
+		}
 		if node.kind == .ident {
 			if local_ct := g.local_storage_c_type(node.value) {
 				if local_ct == 'Optional' || local_ct.starts_with('Optional_') {
@@ -14084,7 +14088,15 @@ fn (mut g FlatGen) gen_lowered_mut_value_storage_arg(arg_id flat.NodeId, arg_nod
 	if g.tc.c_type(g.usable_expr_type(arg_id)) != g.tc.c_type(expected) {
 		return false
 	}
-	g.gen_expr(child_id)
+	local_ct := g.local_storage_c_type(child.value) or { '' }
+	expected_ct := g.tc.c_type(expected)
+	if local_ct == '${expected_ct}*' {
+		// `for mut item in []&T` stores the binding as `T**`. The lowered
+		// `*item` is already the `T*` expected by a `mut T` parameter.
+		g.gen_expr(arg_id)
+	} else {
+		g.gen_expr(child_id)
+	}
 	return true
 }
 
@@ -15739,6 +15751,15 @@ fn (mut g FlatGen) implicit_veb_ctx_type() types.Type {
 }
 
 fn (mut g FlatGen) fn_node_return_type(node flat.Node, module_name string) types.Type {
+	// Runtime helpers in `builtin` can share their bare name with a user function
+	// in `main`. The global bare-name signature table is ambiguous in that case;
+	// the declaration annotation remains module-local and authoritative.
+	if module_name in ['', 'main', 'builtin'] && c_main_runtime_shadow_fn_names[node.value] {
+		declared := g.tc.parse_resolution_type(node.typ)
+		if declared !is types.Unknown {
+			return declared
+		}
+	}
 	if g.tc.autofree_mode && module_name in ['', 'main'] {
 		for key in [node.value, dotted_fn_name_in_module(module_name, node.value)] {
 			if raw_return := g.tc.fn_ret_type_texts[key] {

vlib/v3/gen/c/interface.v

@@ -161,14 +161,18 @@ fn (mut g FlatGen) interface_dispatch_def_string(iface_name string, cn string, m
 }
 
 fn (g &FlatGen) interface_dispatch_receiver_expr(concrete string, concrete_params []types.Type, wants_ptr bool) string {
-	cct := g.interface_concrete_storage_c_type(concrete)
+	concrete_cct := g.interface_concrete_storage_c_type(concrete)
 	if concrete_params.len == 0 {
-		return if wants_ptr { '(${cct}*)i->_object' } else { '*(${cct}*)i->_object' }
+		return if wants_ptr {
+			'(${concrete_cct}*)i->_object'
+		} else {
+			'*(${concrete_cct}*)i->_object'
+		}
 	}
 	concrete_type := g.interface_concrete_type(concrete)
 	expected_type := concrete_params[0]
 	if path := g.embedded_receiver_path_for_expected(concrete_type, expected_type) {
-		base := '(${cct}*)i->_object'
+		base := '(${concrete_cct}*)i->_object'
 		mut access := base
 		mut access_is_ptr := true
 		for field in path {
@@ -181,7 +185,23 @@ fn (g &FlatGen) interface_dispatch_receiver_expr(concrete string, concrete_param
 		}
 		return if wants_ptr { '&(${access})' } else { '*(${access})' }
 	}
-	return if wants_ptr { '(${cct}*)i->_object' } else { '*(${cct}*)i->_object' }
+	// Generic interface indexes retain the open receiver spelling (Box), while
+	// the selected method signature carries its materialized receiver
+	// (Box[Local]). The boxed object uses the latter storage type.
+	expected_value_type := types.unwrap_pointer(expected_type)
+	mut storage_cct := if expected_value_type is types.Unknown {
+		concrete_cct
+	} else {
+		g.tc.c_type(expected_value_type)
+	}
+	if storage_cct.starts_with('fn_ptr:') {
+		storage_cct = naming.fn_ptr_type_name(storage_cct)
+	}
+	return if wants_ptr {
+		'(${storage_cct}*)i->_object'
+	} else {
+		'*(${storage_cct}*)i->_object'
+	}
 }
 
 fn (g &FlatGen) interface_arg_conversion_expr(name string, source_type types.Type, target_type types.Type) ?string {

vlib/v3/gen/c/stmt.v

@@ -3648,7 +3648,8 @@ fn (g &FlatGen) heap_local_memdup_expr(source_expr string, base_type types.Type,
 	}
 	for name in names {
 		if align := g.struct_decl_alignment_for_name(name) {
-			align_arg := struct_decl_alignment_memdup_arg(align, base_ct)
+			align_ct := g.struct_decl_alignment_c_type(clean_base.name(), base_ct)
+			align_arg := struct_decl_alignment_memdup_arg(align, align_ct)
 			return '(${base_ct}*)v3_aligned_memdup(${src}, sizeof(${base_ct}), ${align_arg})'
 		}
 	}
@@ -5529,6 +5530,12 @@ fn (mut g FlatGen) gen_decl_assign(node flat.Node) {
 			} else {
 				g.usable_expr_type(rhs_id)
 			}
+			if rhs.kind == .call && lhs.typ.starts_with('(') && lhs.typ.contains(',') {
+				declared_ret := g.declared_call_return_type(rhs_id)
+				if declared_ret is types.MultiReturn {
+					v_type = declared_ret
+				}
+			}
 			if rhs.kind == .call && rhs.children_count > 0 {
 				callee := g.a.child_node(&rhs, 0)
 				if callee.kind == .selector {
@@ -5570,6 +5577,12 @@ fn (mut g FlatGen) gen_decl_assign(node flat.Node) {
 					v_type = rhs_type
 				}
 			}
+			if rhs.kind == .struct_init && v_type is types.Struct && v_type.name == 'Optional' {
+				rhs_type := g.usable_expr_type(rhs_id)
+				if rhs_type is types.OptionType || rhs_type is types.ResultType {
+					v_type = rhs_type
+				}
+			}
 			if rhs.kind == .struct_init {
 				init_name := g.struct_init_effective_type_name(rhs_id, rhs)
 				if init_name.starts_with('&') {

vlib/v3/gen/c/struct.v

@@ -131,6 +131,11 @@ fn is_anonymous_struct_type_name(name string) bool {
 }
 
 fn (mut g FlatGen) struct_init_effective_type_name(id flat.NodeId, node flat.Node) string {
+	if node.typ == node.value && node.typ.contains('[') && node.typ.contains('.') {
+		// A specialized clone's explicit type annotation is newer than the
+		// checker's expression cache and can retain nested main-module locks.
+		return node.typ
+	}
 	if node.value.starts_with('main.') && !node.value['main.'.len..].contains('.') {
 		// Monomorphization pins a caller-owned program type with `main.` when the
 		// generic declaration's module has a same-named type. The expression type
@@ -447,7 +452,12 @@ fn (mut g FlatGen) gen_struct_init(id flat.NodeId) {
 	}
 	if is_optional_init && !has_expected_optional
 		&& (g.cur_fn_is_specialized || g.name_uses_specialized_generic_abi(g.cur_fn_name)) {
-		name = g.fn_return_type_name(g.cur_fn_ret)
+		concrete_type := if node_type is types.OptionType || node_type is types.ResultType {
+			node_type
+		} else {
+			g.cur_fn_ret
+		}
+		name = g.concrete_optional_type_name(concrete_type)
 	}
 	// A bare generic literal stores its fields under the concrete instance key (`Box[int]`);
 	// the bare `node.value` (`Box`) entry is removed by monomorphization, so resolve the
@@ -800,6 +810,15 @@ fn (mut g FlatGen) struct_init_has_fixed_array_field(node flat.Node, type_name s
 			}
 		}
 	}
+	if fields := g.struct_fields_for_type(type_name) {
+		for field in fields {
+			if fixed := array_fixed_type(field.typ) {
+				if g.field_needs_default_init(fixed.elem_type) {
+					return true
+				}
+			}
+		}
+	}
 	return false
 }
 
@@ -957,6 +976,23 @@ fn (mut g FlatGen) gen_struct_init_with_fixed_array_fields_impl(node flat.Node,
 		g.gen_fixed_array_copy_source(fixed_values[i], fixed_field_types[i])
 		g.write(', sizeof(${tmp}.${cfield}));')
 	}
+	if fields := g.struct_fields_for_type(lookup_name) {
+		for field in fields {
+			if field.name in set_fields {
+				continue
+			}
+			if fixed := array_fixed_type(field.typ) {
+				if g.field_needs_default_init(fixed.elem_type) {
+					cfield := c_field_name(field.name)
+					for idx in 0 .. fixed.len {
+						g.write(' ${tmp}.${cfield}[${idx}] = ')
+						g.gen_default_value_for_type(fixed.elem_type)
+						g.write(';')
+					}
+				}
+			}
+		}
+	}
 	if heap {
 		if align := g.struct_decl_alignment_for_init_names(node.value, name) {
 			align_arg := struct_decl_alignment_memdup_arg(align, name)
@@ -3842,6 +3878,37 @@ fn struct_decl_alignment_memdup_arg(align StructDeclAlignment, c_type string) st
 	return '__alignof__(${c_type})'
 }
 
+fn (g &FlatGen) struct_decl_alignment_c_type(type_name string, fallback string) string {
+	resolved_name := g.struct_init_resolved_decl_name(type_name)
+	if resolved_name.len == 0 {
+		return fallback
+	}
+	ct := g.tc.c_type(g.tc.parse_type(resolved_name))
+	if ct.len == 0 || ct == 'void' {
+		return fallback
+	}
+	if fallback != ct && fallback.ends_with('__${ct}') {
+		return fallback
+	}
+	if qualified_ct := g.unique_qualified_struct_c_type(ct) {
+		return qualified_ct
+	}
+	// Main-module declarations are bare-keyed in the semantic tables, while C
+	// emits their typedefs with the `main__` namespace.
+	if !resolved_name.contains('.') && resolved_name in g.tc.structs {
+		decl_module := g.tc.struct_modules[resolved_name] or { '' }
+		if decl_module in ['', 'main'] {
+			return 'main__${g.cname(resolved_name)}'
+		}
+	}
+	if info := g.find_struct_decl(resolved_name) {
+		if !resolved_name.contains('.') && info.module in ['', 'main'] {
+			return 'main__${g.cname(resolved_name)}'
+		}
+	}
+	return ct
+}
+
 fn (g &FlatGen) struct_type_alias_target(type_name string) ?string {
 	qname := g.tc.qualify_name(type_name)
 	if target := g.tc.type_aliases[qname] {
@@ -4386,7 +4453,8 @@ fn (mut g FlatGen) gen_heap_assoc_expr(node flat.Node) {
 		}
 	}
 	if align := g.heap_assoc_struct_alignment(node, target_type, target_name, ct) {
-		align_arg := struct_decl_alignment_memdup_arg(align, ct)
+		align_ct := g.struct_decl_alignment_c_type(target_name, ct)
+		align_arg := struct_decl_alignment_memdup_arg(align, align_ct)
 		g.write(' (${ct}*)v3_aligned_memdup(&${tmp}, sizeof(${ct}), ${align_arg});})')
 	} else {
 		g.write(' (${ct}*)memdup(&${tmp}, sizeof(${ct}));})')

vlib/v3/parser/parser.v

@@ -5302,18 +5302,25 @@ fn (mut p Parser) parse_comptime_expr() flat.NodeId {
 	p.next() // skip $
 	match p.tok {
 		.key_typeof {
+			p.record_diagnostic('`$typeof` is not supported; use `typeof(...)` instead', dollar_pos)
 			return p.typeof_expr()
 		}
 		.key_sizeof {
+			p.record_diagnostic('`$sizeof` is not supported; use `sizeof(...)` instead', dollar_pos)
 			return p.sizeof_expr()
 		}
 		.key_isreftype {
+			p.record_diagnostic('`$isreftype` is not supported; use `isreftype(...)` instead',
+				dollar_pos)
 			return p.isreftype_expr()
 		}
 		.key_offsetof {
+			p.record_diagnostic('`$__offsetof` is not supported; use `__offsetof(...)` instead',
+				dollar_pos)
 			return p.offsetof_expr()
 		}
 		.key_dump {
+			p.record_diagnostic('`$dump` is not supported; use `dump(...)` instead', dollar_pos)
 			return p.dump_expr()
 		}
 		else {}
@@ -7835,7 +7842,7 @@ fn (mut p Parser) asm_stmt() flat.NodeId {
 	if p.tok == .semicolon {
 		p.next()
 	}
-	if !p.prefs.supports_inline_asm && has_unsupported_content {
+	if !p.prefs.supports_inline_asm && (has_memory_clobber || has_unsupported_content) {
 		p.record_diagnostic('inline assembly is not supported by the selected V3 backend', asm_pos)
 	}
 	return p.add_node(flat.Node{
@@ -9491,9 +9498,6 @@ fn (mut p Parser) prefix_expr() flat.NodeId {
 			return p.if_stmt()
 		}
 		.key_match {
-			if p.peek() in [.lpar, .lsbr] {
-				return p.keyword_ident_expr()
-			}
 			return p.match_stmt()
 		}
 		.key_fn {
@@ -11416,7 +11420,7 @@ fn (mut p Parser) typeof_expr() flat.NodeId {
 	p.check(.lpar)
 	inner := p.expr(.lowest)
 	p.check(.rpar)
-	if !p.inside_array_init_type_expr && p.tok != .dot
+	if !p.inside_array_init_type_expr && p.tok != .dot && (start == 0 || p.s.src[start - 1] != `$`)
 		&& p.line_nr_for_pos(start) == p.line_nr_for_pos(p.tok_pos) {
 		p.record_warning_span('use e.g. `typeof(expr).name` or `sum_type_instance.type_name()` instead',
 			start, start + 'typeof'.len)