v3: fix Linux alias regressions

Author: medvednikov

vlib/v3/transform/expr.v

@@ -832,7 +832,8 @@ fn (mut t Transformer) transform_infix_struct_ops(_id flat.NodeId, node flat.Nod
 			lhs_type = t.smartcast_target_type(sc)
 		}
 	}
-	if lhs_type.len == 0 {
+	if lhs_type.len == 0
+		|| (t.generic_arg_is_unresolved(lhs_type) && !t.generic_arg_is_unresolved(checker_lhs_type)) {
 		lhs_type = checker_lhs_type
 	}
 	lhs_node := t.a.nodes[int(lhs_id)]
@@ -1204,6 +1205,12 @@ fn (t &Transformer) raw_checker_node_type(id flat.NodeId) string {
 }
 
 fn (t &Transformer) raw_alias_type_for_expr(id flat.NodeId) string {
+	if raw_var_type := t.raw_var_type_for_expr(id) {
+		clean_var_type := t.trim_pointer_type(raw_var_type)
+		if t.is_type_alias_name(clean_var_type) {
+			return raw_var_type
+		}
+	}
 	raw_type := t.raw_checker_node_type(id)
 	if raw_type.len == 0 {
 		return ''
@@ -1213,6 +1220,17 @@ fn (t &Transformer) raw_alias_type_for_expr(id flat.NodeId) string {
 	if t.is_type_alias_name(clean) {
 		return raw_type
 	}
+	node := t.a.nodes[int(id)]
+	if node.kind == .infix && node.children_count > 0 {
+		lhs_id := t.a.child(&node, 0)
+		if lhs_type := t.raw_var_type_for_expr(lhs_id) {
+			clean_lhs_type := t.trim_pointer_type(lhs_type)
+			if t.is_type_alias_name(clean_lhs_type)
+				&& t.normalize_type_alias(clean_lhs_type) == t.normalize_type_alias(clean) {
+				return lhs_type
+			}
+		}
+	}
 	if is_ptr {
 		return ''
 	}

vlib/v3/transform/monomorphize.v

@@ -9487,9 +9487,6 @@ fn (mut t Transformer) generic_comptime_typeof_target(node flat.Node, args []str
 		}
 	}
 	target := t.generic_comptime_base_type(child_id, args) or { return none }
-	if child.kind == .ident && t.mut_param_values[child.value] && !target.starts_with('&') {
-		return '&${target}'
-	}
 	return target
 }
 

vlib/v3/transform/transform.v

@@ -13365,6 +13365,12 @@ fn (mut t Transformer) transform_decl_assign_stmt(id flat.NodeId, node flat.Node
 				} else if inferred := t.building_v_math_generic_call_type(rhs) {
 					typ = inferred
 				}
+				if t.generic_arg_is_unresolved(typ) {
+					checker_typ := t.checker_node_type(rhs_id)
+					if decl_type_is_usable(checker_typ) && !t.generic_arg_is_unresolved(checker_typ) {
+						typ = checker_typ
+					}
+				}
 			}
 			if rhs.kind == .call && t.is_strings_builder_new_call(rhs_id, rhs) {
 				typ = 'strings.Builder'

vlib/v3/types/checker.v

@@ -8281,7 +8281,9 @@ pub fn (mut tc TypeChecker) check_semantics() {
 						tc.check_pascal_case_name(node_id, node.value, type_kind, tc.declaration_keyword_name_pos(node_id,
 							'type'))
 					}
-					if tc.type_declaration_exists_before(node_id, node.value) {
+					is_c_alias := node.value.starts_with('C.') && node.children_count == 0
+						&& split_sum_variant_texts(node.typ).len <= 1
+					if !is_c_alias && tc.type_declaration_exists_before(node_id, node.value) {
 						kind := if node.children_count > 0
 							|| split_sum_variant_texts(node.typ).len > 1 {
 							'sum type'

vlib/v3/types/checker_comptime.v

@@ -3595,7 +3595,7 @@ fn (mut tc TypeChecker) check_prefix_expr(id flat.NodeId, node flat.Node) {
 	}
 	if node.op == .amp && address_child.kind == .index && address_child.children_count > 0 {
 		base_id := tc.a.child(&address_child, 0)
-		base_type := unalias_and_unwrap_pointer_type(tc.resolve_type(base_id))
+		base_type := unwrap_pointer(tc.resolve_type(base_id))
 		if base_type is Map && tc.unsafe_depth == 0 && !tc.expr_is_inside_unsafe_block(id) {
 			tc.record_error_at(.assignment_mismatch,
 				'cannot take the address of map values outside `unsafe`', child_id,

vlib/v3/types/checker_parallel.v

@@ -987,7 +987,10 @@ fn (mut tc TypeChecker) check_top_level_declarations_filtered(do_values bool, do
 					continue
 				}
 				node_id := flat.NodeId(i)
-				if node.kind == .type_decl && tc.type_declaration_exists_before(node_id, node.value) {
+				is_c_alias := node.kind == .type_decl && node.value.starts_with('C.')
+					&& node.children_count == 0 && split_sum_variant_texts(node.typ).len <= 1
+				if node.kind == .type_decl && !is_c_alias
+					&& tc.type_declaration_exists_before(node_id, node.value) {
 					kind := if node.children_count > 0 || split_sum_variant_texts(node.typ).len > 1 {
 						'sum type'
 					} else {