all: more generics optimizations

Author: medvednikov

vlib/v/ast/table.v

@@ -2127,6 +2127,23 @@ pub fn (t &Table) is_sumtype_or_in_variant(parent Type, typ Type) bool {
 // can_implicit_array_cast reports whether `got` can be converted to `expected`
 // by boxing each array element into the expected interface or sum type.
 pub fn (t &Table) can_implicit_array_cast(got Type, expected Type) bool {
+	if got == 0 || expected == 0 || got == expected {
+		return false
+	}
+	got_idx := got.idx()
+	expected_idx := expected.idx()
+	if got_idx == expected_idx {
+		return false
+	}
+	if got_idx > 0 && got_idx < t.type_symbols.len && expected_idx > 0
+		&& expected_idx < t.type_symbols.len {
+		got_kind := t.type_symbols[got_idx].kind
+		expected_kind := t.type_symbols[expected_idx].kind
+		if (got_kind != .array && got_kind != .alias)
+			|| (expected_kind != .array && expected_kind != .alias) {
+			return false
+		}
+	}
 	got_unaliased := t.unaliased_type(got)
 	expected_unaliased := t.unaliased_type(expected)
 	got_sym := t.final_sym(got_unaliased)

vlib/v/checker/checker.v

@@ -4603,8 +4603,20 @@ fn (mut c Checker) stmts_ending_with_expression(mut stmts []ast.Stmt, expected_o
 	c.scope_returns = false
 }
 
+@[inline]
 fn (mut c Checker) unwrap_generic(typ ast.Type) ast.Type {
-	has_generic_parts := typ.has_flag(.generic) || c.type_has_unresolved_generic_parts(typ)
+	if typ == 0 {
+		return typ
+	}
+	has_generic_flag := typ.has_flag(.generic)
+	if !has_generic_flag {
+		idx := typ.idx()
+		if idx <= ast.nil_type_idx
+			|| (idx < c.generic_parts_cache.len && c.generic_parts_cache[idx] == 1) {
+			return typ
+		}
+	}
+	has_generic_parts := has_generic_flag || c.type_has_unresolved_generic_parts(typ)
 	if !has_generic_parts {
 		return typ
 	}

vlib/v/gen/c/fn.v

@@ -533,6 +533,39 @@ fn (mut g Gen) specialized_method_name_from_receiver(method ast.Fn, concrete_rec
 	return g.generic_fn_name(specialization_types, base_name)
 }
 
+fn (mut g Gen) specialized_method_name_from_receiver_context(method ast.Fn, receiver_concrete_types []ast.Type, parent_method ast.Fn, base_name string) string {
+	if receiver_concrete_types.len == 0 || method.params.len == 0 {
+		return base_name
+	}
+	method_receiver_generic_names := g.table.generic_type_names(method.params[0].typ)
+	parent_receiver_generic_names := if parent_method.params.len > 0 {
+		g.table.generic_type_names(parent_method.params[0].typ)
+	} else {
+		[]string{}
+	}
+	full_method := if parent_method.generic_names.len > method.generic_names.len
+		|| (method_receiver_generic_names.len == 0 && parent_receiver_generic_names.len > 0) {
+		parent_method
+	} else {
+		method
+	}
+	receiver_generic_names := g.table.generic_type_names(full_method.params[0].typ)
+	if receiver_generic_names.len == 0 {
+		if full_method.generic_names.len != receiver_concrete_types.len {
+			return base_name
+		}
+	} else if full_method.generic_names.len > 0
+		&& (full_method.generic_names.len != receiver_generic_names.len
+		|| full_method.generic_names != receiver_generic_names) {
+		return base_name
+	}
+	specialized_suffix := g.generic_fn_name(receiver_concrete_types, '')
+	if specialized_suffix != '' && base_name.ends_with(specialized_suffix) {
+		return base_name
+	}
+	return g.generic_fn_name(receiver_concrete_types, base_name)
+}
+
 fn (mut g Gen) recover_method_call_concrete_types_from_name(raw_method_name string, method_name string, receiver_type ast.Type, method_for_generics ast.Fn, parent_generic_method ast.Fn) []ast.Type {
 	if raw_method_name == '' || method_name == ''
 		|| !raw_method_name.starts_with(method_name + '_T_') {
@@ -2836,17 +2869,16 @@ fn (mut g Gen) resolve_return_type(node ast.CallExpr) ast.Type {
 		func := left_sym.find_method_with_generic_parent(node.name) or {
 			g.table.find_method(left_sym, node.name) or { return ast.void_type }
 		}
-		receiver_concrete_types, parent_method := g.receiver_generic_call_context(left_type,
-			node.name)
 		if func.return_type != 0 && !func.return_type.has_flag(.generic)
-			&& !g.type_has_unresolved_generic_parts(func.return_type)
-			&& !(receiver_concrete_types.len > 0 && parent_method.params.len > 0) {
+			&& !g.type_has_unresolved_generic_parts(func.return_type) {
 			return if node.or_block.kind == .absent {
 				func.return_type
 			} else {
 				func.return_type.clear_option_and_result()
 			}
 		}
+		receiver_concrete_types, parent_method := g.receiver_generic_call_context(left_type,
+			node.name)
 		if func.generic_names.len > 0 {
 			mut concrete_types := if node.concrete_types.len == func.generic_names.len
 				&& node.concrete_types.all(it != 0 && !it.has_flag(.generic)
@@ -4712,7 +4744,8 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
 		method_for_generics.generic_names.clone()
 	}
 	if has_method {
-		name = g.specialized_method_name_from_receiver(full_method, receiver_type, name)
+		name = g.specialized_method_name_from_receiver_context(full_method,
+			receiver_concrete_types, parent_generic_method, name)
 	}
 	if has_method && full_method_generic_names_len == 0 {
 		concrete_types = []ast.Type{}

vlib/v/gen/c/utils.v

@@ -59,6 +59,17 @@ fn (g &Gen) expr_resolution_cache_key(pos int, default_typ ast.Type, salt u64) u
 	return key ^ salt
 }
 
+@[inline]
+fn (g &Gen) type_is_known_concrete(typ ast.Type) bool {
+	if typ == 0 || typ.has_flag(.generic) {
+		return false
+	}
+	idx := typ.idx()
+	return idx <= ast.nil_type_idx
+		|| (idx < g.generic_parts_cache.len && g.generic_parts_cache[idx] == 1)
+}
+
+@[inline]
 fn (mut g Gen) unwrap_generic(typ ast.Type) ast.Type {
 	if typ == 0 {
 		return typ
@@ -70,6 +81,10 @@ fn (mut g Gen) unwrap_generic(typ ast.Type) ast.Type {
 			return typ
 		}
 	}
+	return g.unwrap_generic_slow(typ)
+}
+
+fn (mut g Gen) unwrap_generic_slow(typ ast.Type) ast.Type {
 	cache_key := g.type_resolution_cache_key(typ, cgen_unwrap_generic_cache_salt)
 	if cached := g.unwrap_generic_cache[cache_key] {
 		return cached
@@ -986,6 +1001,15 @@ fn (mut g Gen) resolved_expr_type(expr ast.Expr, default_typ ast.Type) ast.Type
 		}
 		ast.Ident {
 			if expr.obj is ast.Var {
+				if expr.obj.typ != 0 && expr.obj.generic_typ == 0 && !expr.obj.is_inherited
+					&& !expr.obj.is_unwrapped && !expr.obj.is_assignment_smartcast
+					&& !expr.obj.is_or && expr.obj.orig_type == ast.no_type
+					&& expr.obj.smartcasts.len == 0 && expr.obj.ct_type_var == .no_comptime
+					&& !g.has_current_generic_context() && !g.has_active_call_generic_context() {
+					if g.type_is_known_concrete(expr.obj.typ) {
+						return expr.obj.typ
+					}
+				}
 				if g.cur_fn != unsafe { nil } && g.cur_fn.is_method
 					&& expr.name == g.cur_fn.receiver.name {
 					// In generic contexts, prefer resolving from the receiver declaration

vlib/v/markused/walker.v

@@ -132,22 +132,24 @@ fn (mut w Walker) mark_fn_as_used(fkey string) {
 }
 
 fn (w &Walker) fn_generic_names(node ast.FnDecl) []string {
+	if !node.is_method {
+		return node.generic_names
+	}
 	mut generic_names := []string{}
-	if node.is_method {
-		receiver_sym := w.table.sym(node.receiver.typ)
-		match receiver_sym.info {
-			ast.Struct {
-				generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
-			}
-			ast.Interface {
-				generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
-			}
-			ast.SumType {
-				generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
-			}
-			else {}
+	receiver_sym := w.table.sym(node.receiver.typ)
+	match receiver_sym.info {
+		ast.Struct {
+			generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
+		}
+		ast.Interface {
+			generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
 		}
+		ast.SumType {
+			generic_names << w.table.get_generic_names(receiver_sym.info.generic_types)
+		}
+		else {}
 	}
+
 	// Only add method-level generic names that aren't already from the receiver
 	// (V puts inherited receiver generics into node.generic_names too).
 	for gn in node.generic_names {