make_compile

Author: medvednikov

vlib/v/ast/table.v

@@ -2164,7 +2164,7 @@ pub fn (t &Table) does_type_implement_interface(typ Type, inter_typ Type) bool {
 			}
 			return false
 		}
-		if !is_interface_upcast && typ != voidptr_type && typ != nil_type && typ != none_type
+		if sym.kind != .interface && typ != voidptr_type && typ != nil_type && typ != none_type
 			&& !inter_sym.info.types.contains(typ) {
 			inter_sym.info.types << typ
 		}

vlib/v/builder/cc.v

@@ -1302,58 +1302,6 @@ fn (mut b Builder) cc_linux_cross() {
 		verror(cc_res.output)
 		return
 	}
-	// Compile extra .c source files (from `#flag @VMODROOT/file.c` etc.)
-	// separately for the cross target, and collect the resulting .o files.
-	mut extra_obj_files := []string{cap: extra_c_sources.len}
-	for csource in extra_c_sources {
-		extra_obj := csource + '.o'
-		mut extra_cc_args := []string{cap: 10}
-		extra_cc_args << '-w'
-		extra_cc_args << '-fPIC'
-		extra_cc_args << '-target x86_64-linux-gnu'
-		extra_cc_args << defines
-		extra_cc_args << conly_flags
-		extra_cc_args << '-I ${os.quoted_path('${sysroot}/include')} '
-		extra_cc_args << '-o ${os.quoted_path(extra_obj)}'
-		extra_cc_args << '-c ${os.quoted_path(csource)}'
-		extra_cmd := '${b.quote_compiler_name(cc_name)} ' + extra_cc_args.join(' ')
-		if b.pref.show_cc {
-			println(extra_cmd)
-		}
-		extra_res := os.execute(extra_cmd)
-		if extra_res.exit_code != 0 {
-			println('Cross compilation for Linux failed (compiling ${csource}).')
-			verror(extra_res.output)
-			return
-		}
-		extra_obj_files << os.quoted_path(extra_obj)
-	}
-	// For libraries that only exist as static .a in the sysroot (e.g. libpq.a),
-	// create shared library stubs so the linker produces a dynamically linked binary
-	// instead of pulling in incomplete static archives with missing internal deps.
-	lib_search_paths := [
-		os.join_path(sysroot, 'usr', 'lib', 'x86_64-linux-gnu'),
-		os.join_path(sysroot, 'lib', 'x86_64-linux-gnu'),
-	]
-	stubs_dir := os.join_path(os.vtmp_dir(), 'cross_linux_stubs')
-	os.mkdir_all(stubs_dir) or {}
-	for lib in libs {
-		libname := lib.replace('-l', '')
-		if libname in ['c', 'pthread', 'm', 'dl'] {
-			continue // standard libs, always available
-		}
-		has_so := lib_search_paths.any(os.exists(os.join_path(it, 'lib${libname}.so')))
-		has_a := !has_so && lib_search_paths.any(os.exists(os.join_path(it, 'lib${libname}.a')))
-		if has_a {
-			a_path := lib_search_paths.map(os.join_path(it, 'lib${libname}.a')).filter(os.exists(it))[0] or {
-				continue
-			}
-			stub_so := os.join_path(stubs_dir, 'lib${libname}.so')
-			if !os.exists(stub_so) {
-				b.create_shared_lib_stub(cc_name, a_path, stub_so, sysroot)
-			}
-		}
-	}
 	// Compile compiler runtime builtins (provides __udivti3 etc. for 128-bit integer
 	// operations used by thirdparty code like mbedtls bignum.c, since the linuxroot
 	// sysroot doesn't include libgcc or compiler-rt).

vlib/v/checker/check_types.v

@@ -1315,14 +1315,15 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
 				if arg.expr.is_auto_deref_var() && typ.is_ptr() {
 					if !arg.is_mut {
 						typ = typ.deref()
-					} else if arg.expr is ast.Ident && arg.expr.obj is ast.Var
-						&& arg.expr.obj.generic_typ == 0 {
-						// Non-generic auto-deref mut param: obj.typ includes the
-						// mut pointer (e.g. mut ctx Context → obj.typ=&Context),
-						// so strip it for generic inference.
-						// Generic auto-deref mut params (generic_typ != 0) already
-						// have the correct resolved type without extra mut pointer.
-						typ = typ.deref()
+					} else if arg.expr is ast.Ident && arg.expr.obj is ast.Var {
+						if arg.expr.obj.generic_typ == 0 {
+							// Non-generic auto-deref mut param: obj.typ includes the
+							// mut pointer (e.g. mut ctx Context → obj.typ=&Context),
+							// so strip it for generic inference.
+							// Generic auto-deref mut params (generic_typ != 0) already
+							// have the correct resolved type without extra mut pointer.
+							typ = typ.deref()
+						}
 					}
 				}
 				// resolve &T &&T ...

vlib/v/checker/checker.v

@@ -3119,24 +3119,6 @@ fn (mut c Checker) enum_decl(mut node ast.EnumDecl) {
 							field.expr.pos)
 					}
 				}
-				ast.IfExpr {
-					c.if_expr(mut field.expr)
-					if comptime_value := c.eval_comptime_const_expr(field.expr, 0) {
-						comptime_lit := c.comptime_value_to_integer_literal(comptime_value,
-							field.expr.pos) or {
-							c.error('the default value for an enum has to be an integer',
-								field.expr.pos)
-							continue
-						}
-						c.check_enum_field_integer_literal(comptime_lit, signed,
-							node.is_multi_allowed, senum_type, field.expr.pos, mut useen,
-							enum_umin, enum_umax, mut iseen, enum_imin, enum_imax)
-						field.expr = comptime_lit
-					} else {
-						c.error('the default value for an enum has to be an integer',
-							field.expr.pos)
-					}
-				}
 				else {
 					if mut field.expr is ast.Ident {
 						if field.expr.language == .c {

vlib/v/checker/fn.v

@@ -3320,11 +3320,6 @@ fn (mut c Checker) method_call(mut node ast.CallExpr, mut continue_check &bool)
 		if exp_arg_typ.has_flag(.generic) {
 			has_unresolved_generic_param = c.check_unresolved_generic_param(node, arg)
 				|| has_unresolved_generic_param
-			method_concrete_types := if method_generic_names_len == rec_concrete_types.len {
-				rec_concrete_types
-			} else {
-				concrete_types
-			}
 			if exp_utyp := c.table.convert_generic_param_type(param, method.generic_names,
 				method_concrete_types)
 			{

vlib/v/checker/if.v

@@ -783,7 +783,7 @@ fn (mut c Checker) smartcast_if_conds(mut node ast.Expr, mut scope ast.Scope, co
 			if left_sym.kind in [.interface, .sum_type] || is_option_unwrap {
 				mut left_expr := first_cond.left
 				c.smartcast(mut left_expr, left_type, right_type, mut scope,
-					false, is_option_unwrap)
+					false, is_option_unwrap, false)
 			}
 		}
 		c.smartcast_none_guard_unwrap(control_expr.branches[0].cond, mut scope)

vlib/v/gen/c/assign.v

@@ -63,8 +63,7 @@ fn (mut g Gen) gen_self_recursing_anon_fn_capture_patch(left ast.Expr, anon_fn a
 	if ident.name !in anon_fn.inherited_vars.map(it.name) {
 		return
 	}
-	concrete_types := g.get_anon_fn_concrete_types(anon_fn)
-	ctx_struct := g.closure_ctx(anon_fn.decl, concrete_types)
+	ctx_struct := g.closure_ctx(anon_fn.decl)
 	left_expr := g.expr_string(left)
 	g.writeln('((${ctx_struct}*)builtin__closure__closure_data(${left_expr}))->${c_name(ident.name)} = ${left_expr};')
 }

vlib/v/gen/c/cgen.v

@@ -200,8 +200,9 @@ mut:
 	threaded_fns               shared []string // for generating unique wrapper types and fns for `go xxx()`
 	waiter_fns                 shared []string // functions that wait for `go xxx()` to finish
 	needed_equality_fns        []ast.Type
-	generated_eq_fns           []ast.Type
-	array_sort_fn              shared []string
+	generated_eq_fns                   []ast.Type
+	generated_array_interface_cast_fns shared map[string]bool
+	array_sort_fn                      shared []string
 	array_contains_types       []ast.Type
 	array_index_types          []ast.Type
 	array_last_index_types     []ast.Type
@@ -934,8 +935,6 @@ fn cgen_process_one_file_cb(mut p pool.PoolProcessor, idx int, wid int) voidptr
 		done_typedef_phase:     global_g.done_typedef_phase
 		array_typedefs:         global_g.array_typedefs.clone()
 		written_array_typedefs: global_g.written_array_typedefs
-		static_modifier:        global_g.static_modifier
-		static_non_parallel:    global_g.static_non_parallel
 		has_reflection:         'v.reflection' in global_g.table.modules
 		has_debugger:           'v.debug' in global_g.table.modules
 		reflection_strings:     global_g.reflection_strings
@@ -4918,7 +4917,7 @@ fn (mut g Gen) expr(node_ ast.Expr) {
 				g.write('(*')
 				g.expr(node.expr)
 				g.write(')')
-			} else if !handled_atomic_postfix && node.op == .question {
+			} else if node.op == .question {
 				mut expr_type := ast.void_type
 				if mut node.expr is ast.ComptimeSelector {
 					if node.expr.field_expr is ast.SelectorExpr
@@ -10807,6 +10806,29 @@ fn (mut g Gen) check_noscan(elem_typ ast.Type) string {
 	return ''
 }
 
+fn (mut g Gen) write_heap_alloc(styp string, typ ast.Type) {
+	if g.pref.gc_mode == .vgc {
+		ptrmap, _ := g.vgc_ptrmap(typ)
+		if ptrmap.len > 0 {
+			g.write('HEAP_vgc(${styp}, (')
+			return
+		}
+	}
+	g.write('HEAP(${styp}, (')
+}
+
+// write_heap_alloc_close writes the closing part of a HEAP_vgc or HEAP call.
+fn (mut g Gen) write_heap_alloc_close(typ ast.Type) {
+	if g.pref.gc_mode == .vgc {
+		ptrmap, nptrs := g.vgc_ptrmap(typ)
+		if ptrmap.len > 0 {
+			g.write('), ${ptrmap}, ${nptrs})')
+			return
+		}
+	}
+	g.write('))')
+}
+
 // vgc_ptrmap computes a precise pointer bitmap for simple VGC heap allocations.
 fn (mut g Gen) vgc_ptrmap(typ ast.Type) (string, string) {
 	if g.pref.gc_mode != .vgc {

vlib/v/gen/c/dumpexpr.v

@@ -241,9 +241,10 @@ fn (mut g Gen) dump_expr(node ast.DumpExpr) {
 		if expr_type.has_flag(.option_mut_param_t) {
 			g.write('*')
 		}
-		if node.expr is ast.Ident && node.expr.obj is ast.Var && node.expr.obj.is_auto_deref
-			&& !expr_type.is_ptr() {
-			g.write('*')
+		if node.expr is ast.Ident && node.expr.obj is ast.Var {
+			if node.expr.obj.is_auto_deref && !expr_type.is_ptr() {
+				g.write('*')
+			}
 		}
 		for {
 			if node.expr is ast.Ident {

vlib/v/gen/c/infix.v

@@ -264,19 +264,6 @@ fn (mut g Gen) infix_expr_eq_op(node ast.InfixExpr) {
 			g.write(method_name)
 			g.write('__eq')
 		}
-		mut is_builtin_or_alias_to_builtin := left.sym.is_builtin()
-		if !has_alias_eq_op_overload && !is_builtin_or_alias_to_builtin
-			&& left.sym.info is ast.Alias {
-			alias_info := left.sym.info as ast.Alias
-			parent_sym := g.table.sym(alias_info.parent_type)
-			is_builtin_or_alias_to_builtin = parent_sym.is_builtin()
-		}
-		if is_builtin_or_alias_to_builtin {
-			method_name = 'builtin__${method_name}'
-		}
-		mut eq_fn_name := '${method_name}__eq'
-		eq_fn_name = g.specialized_method_name_from_receiver(eq_method, left.typ, eq_fn_name)
-		g.write(eq_fn_name)
 		g.write('(')
 		g.write('*'.repeat(left.typ.nr_muls()))
 		if eq_operator_expects_ptr {