v2: lots of fixes to compile v1

Author: medvednikov

vlib/v2/builder/builder.v

@@ -109,8 +109,6 @@ fn sanitize_staged_c_source(c_source string) string {
 	// UdpSocket result pointer auto-deref: .sock field is UdpSocket (value), result contains &UdpSocket.
 	source = source.replace('.sock = (*(net__UdpSocket**)(((u8*)(&_or_t54.err)) + sizeof(IError)))',
 		'.sock = *(*(net__UdpSocket**)(((u8*)(&_or_t54.err)) + sizeof(IError)))')
-	// Generic function specialization: convert_voidptr_to_t_T -> convert_voidptr_to_t_f64
-	source = source.replace('sync__convert_voidptr_to_t_T(', 'sync__convert_voidptr_to_t_f64(')
 	source = ensure_string_eq_impl(source)
 	// ObjC .m file references g_vui_webview_cookie_val as a global variable.
 	// The cleanc backend uses DarwinWebViewState singleton instead.

vlib/v2/gen/cleanc/array.v

@@ -326,6 +326,15 @@ fn (mut g Gen) array_append_elem_type(lhs ast.Expr, rhs ast.Expr) (bool, string)
 			}
 		}
 	}
+	if is_generic_placeholder_c_type_name(elem_type) {
+		rhs_value := append_rhs_value_expr(rhs)
+		if rhs_value is ast.PrefixExpr && rhs_value.op == .mul && rhs_value.expr is ast.CastExpr {
+			target_type := g.expr_type_to_c(rhs_value.expr.typ)
+			if target_type.ends_with('*') {
+				elem_type = target_type.trim_right('*')
+			}
+		}
+	}
 	// When raw_type gives a module-qualified name (e.g. term__Coord) but the rhs
 	// is a local struct (e.g. Coord), prefer the rhs type to match the actual typedef.
 	if elem_type.contains('__') {
@@ -342,14 +351,40 @@ fn (mut g Gen) array_append_elem_type(lhs ast.Expr, rhs ast.Expr) (bool, string)
 	return true, unmangle_c_ptr_type(elem_type)
 }
 
+fn append_rhs_value_expr(expr ast.Expr) ast.Expr {
+	if expr is ast.UnsafeExpr && expr.stmts.len > 0 {
+		last := expr.stmts[expr.stmts.len - 1]
+		if last is ast.ExprStmt {
+			return last.expr
+		}
+	}
+	return expr
+}
+
 fn (mut g Gen) expr_is_array_value(expr ast.Expr) bool {
 	if expr is ast.ParenExpr {
 		return g.expr_is_array_value(expr.expr)
 	}
+	if expr is ast.UnsafeExpr {
+		return g.expr_is_array_value(append_rhs_value_expr(expr))
+	}
 	if expr is ast.PrefixExpr && expr.op == .mul {
 		// `*ptr_to_array` is an array value.
 		return g.expr_is_array_value(expr.expr)
 	}
+	if expr is ast.Ident {
+		if local_type := g.get_local_var_c_type(expr.name) {
+			if local_type == 'array' || local_type.starts_with('Array_') {
+				return true
+			}
+		}
+	}
+	if expr is ast.SelectorExpr {
+		field_type := g.selector_field_type(expr)
+		if field_type == 'array' || field_type.starts_with('Array_') {
+			return true
+		}
+	}
 	expr_type := g.get_expr_type(expr)
 	if expr_type == 'array' || expr_type.starts_with('Array_') {
 		return true
@@ -875,27 +910,8 @@ fn (mut g Gen) gen_typed_array_eq(elem_type string, call_args []ast.Expr) {
 		struct_type := g.lookup_struct_type_by_c_name(elem_type)
 		if struct_type.fields.len > 0 {
 			for field in struct_type.fields {
-				fname := field.name
-				ftype := field.typ
-				match ftype {
-					types.String {
-						g.sb.writeln('  if (!string__eq(_sa.${fname}, _sb.${fname})) _eq = false;')
-					}
-					types.Map {
-						c_type := g.types_type_to_c(ftype)
-						if c_type.starts_with('Map_') {
-							g.sb.writeln('  if (!${c_type}_map_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
-						} else {
-							g.sb.writeln('  if (!map_map_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
-						}
-					}
-					types.Array {
-						g.sb.writeln('  if (!__v2_array_eq(_sa.${fname}, _sb.${fname})) _eq = false;')
-					}
-					else {
-						g.sb.writeln('  if (_sa.${fname} != _sb.${fname}) _eq = false;')
-					}
-				}
+				eq_expr := g.eq_expr_for_type(field.typ, '_sa.${field.name}', '_sb.${field.name}')
+				g.sb.writeln('  if (!(${eq_expr})) _eq = false;')
 			}
 		} else {
 			// Struct not found, fall back to memcmp

vlib/v2/gen/cleanc/assign.v

@@ -73,7 +73,11 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 			}
 			g.write_indent()
 			g.sb.write_string('${typ} ${name} = ')
-			g.expr(rhs_expr)
+			if typ == 'string' && is_none_like_expr(rhs_expr) {
+				g.sb.write_string('((string){.str = "", .len = 0, .is_lit = 1})')
+			} else {
+				g.expr(rhs_expr)
+			}
 			g.sb.writeln(';')
 			g.remember_runtime_local_type(name, typ)
 		}
@@ -314,6 +318,8 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 		// Rename V variables that clash with C type names
 		if name == 'array' {
 			name = '_v_array'
+		} else {
+			name = escape_c_keyword(name)
 		}
 		// Keep fixed-size arrays as C arrays in local declarations.
 		if rhs is ast.ArrayInitExpr {
@@ -364,6 +370,14 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 			}
 		}
 		mut typ := g.get_expr_type(rhs)
+		mut type_from_selector_field := false
+		if rhs is ast.SelectorExpr {
+			field_type := g.selector_field_type(rhs)
+			if field_type != '' {
+				typ = field_type
+				type_from_selector_field = true
+			}
+		}
 		// For Ident RHS referencing a struct-typed constant (e.g., `col := no_color`
 		// where no_color is `#define`d as a Color struct literal), use the const type.
 		if (typ == 'int' || typ == '') && rhs is ast.Ident {
@@ -383,13 +397,27 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 				typ = cast_type
 			}
 		}
+		if rhs is ast.PrefixExpr && rhs.op == .mul && rhs.expr is ast.CastExpr {
+			cast_type := g.expr_type_to_c(rhs.expr.typ)
+			if cast_type.ends_with('*') {
+				typ = cast_type.trim_right('*')
+			}
+		}
+		rhs_is_concrete_literal := rhs is ast.BasicLiteral || rhs is ast.StringLiteral
 		// For temp variables registered by the transformer with a specific type,
 		// prefer the scope-registered type over the RHS expression type.
 		if name.starts_with('_or_t') || name.starts_with('_tmp_') || name.starts_with('_defer_t') {
 			if raw_type := g.get_raw_type(lhs) {
 				scope_type := g.types_type_to_c(raw_type)
 				if scope_type != '' && scope_type != 'int' {
-					typ = scope_type
+					generic_container_fallback :=
+						(typ == 'array' && scope_type.starts_with('Array_'))
+						|| (typ == 'map' && scope_type.starts_with('Map_'))
+					if !rhs_is_concrete_literal && !type_from_selector_field && (typ == ''
+						|| typ == 'int' || typ == 'int_literal' || typ == 'void*'
+						|| typ == 'voidptr' || generic_container_fallback) {
+						typ = scope_type
+					}
 					// Ensure result/option wrapper types are registered so their
 					// typedef and struct definitions get emitted in the C output.
 					if scope_type.starts_with('_result_') || scope_type.starts_with('_option_') {
@@ -456,6 +484,14 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 				typ = target_type + '*'
 			}
 		}
+		mut type_from_typed_deref := false
+		if rhs is ast.PrefixExpr && rhs.op == .mul && rhs.expr is ast.CastExpr {
+			target_type := g.expr_type_to_c(rhs.expr.typ)
+			if target_type.ends_with('*') {
+				typ = target_type[..target_type.len - 1]
+				type_from_typed_deref = true
+			}
+		}
 		mut elem_type_from_array := false
 		if rhs is ast.CallExpr {
 			if rhs.lhs is ast.Ident
@@ -541,7 +577,8 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 				type_from_tuple_field = sel_lhs.name.starts_with('_tuple_t')
 			}
 		}
-		if !elem_type_from_array && !type_from_tuple_field && name != ''
+		if !elem_type_from_array && !type_from_selector_field && !type_from_tuple_field
+			&& !rhs_is_concrete_literal && !type_from_typed_deref && name != ''
 			&& g.cur_fn_scope != unsafe { nil } {
 			if obj := g.cur_fn_scope.lookup_parent(name, 0) {
 				if obj !is types.Module {
@@ -584,6 +621,12 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 					}
 				}
 			}
+			if typ == '' || typ == 'int' || typ == 'int_literal' {
+				fn_ptr_ret := g.fn_pointer_return_type(rhs.lhs)
+				if fn_ptr_ret != '' && fn_ptr_ret != 'int' && fn_ptr_ret != 'void' {
+					typ = fn_ptr_ret
+				}
+			}
 			// For interface vtable method calls (e.g., w->size(w->_object)),
 			// look up the method's return type from the interface declaration.
 			if (typ == '' || typ == 'int') && rhs.lhs is ast.SelectorExpr {
@@ -623,7 +666,17 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 			is_or_tmp := rhs.lhs is ast.Ident && rhs.lhs.name.starts_with('_or_t')
 			if container_type.starts_with('_result_') || container_type.starts_with('_option_')
 				|| is_or_tmp {
-				cast_type := if typ != '' && typ != 'int_literal' && typ != 'float_literal' {
+				payload_type := if container_type.starts_with('_result_') {
+					g.result_value_type(container_type)
+				} else if container_type.starts_with('_option_') {
+					option_value_type(container_type)
+				} else {
+					''
+				}
+				cast_type := if payload_type != '' {
+					payload_type
+				} else if typ != '' && typ != 'int_literal' && typ != 'float_literal'
+					&& !typ.starts_with('_result_') && !typ.starts_with('_option_') {
 					typ
 				} else if rhs_type != '' && rhs_type != 'int_literal' && rhs_type != 'float_literal' {
 					rhs_type
@@ -832,6 +885,11 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 		if typ == '' || typ == 'void' {
 			typ = 'int'
 		}
+		g.register_alias_type(typ)
+		if typ.starts_with('Array_') && !typ.starts_with('Array_fixed_') && !typ.ends_with('*') {
+			g.sb.writeln('typedef array ${typ};')
+			g.write_indent()
+		}
 		// Check if declaring an interface pointer initialized with a concrete type
 		if typ.ends_with('*') && name != '' {
 			decl_base := typ.trim_right('*')