checker: fix comptime concrete type register (fix #17657) (#17659)

Author: felipensp

vlib/v/checker/checker.v

@@ -73,7 +73,6 @@ pub mut:
 	inside_ct_attr            bool // true inside `[if expr]`
 	inside_x_is_type          bool // true inside the Type expression of `if x is Type {`
 	inside_comptime_for_field bool
-	inside_for_in_any_cond    bool
 	skip_flags                bool      // should `#flag` and `#include` be skipped
 	fn_level                  int       // 0 for the top level, 1 for `fn abc() {}`, 2 for a nested fn, etc
 	smartcast_mut_pos         token.Pos // match mut foo, if mut foo is Foo
@@ -95,7 +94,6 @@ mut:
 	loop_label                       string     // set when inside a labelled for loop
 	vweb_gen_types                   []ast.Type // vweb route checks
 	timers                           &util.Timers = util.get_timers()
-	for_in_any_val_type              ast.Type
 	comptime_for_field_var           string
 	comptime_fields_default_type     ast.Type
 	comptime_fields_key_type         ast.Type // key type on `$for k, v in val.$(field.name)`

vlib/v/checker/comptime.v

@@ -10,15 +10,20 @@ import v.util
 import v.pkgconfig
 import v.checker.constants
 
+[inline]
+fn (mut c Checker) get_comptime_var_type_from_kind(kind ast.ComptimeVarKind) ast.Type {
+	return match kind {
+		.key_var { c.comptime_fields_key_type }
+		.value_var { c.comptime_fields_val_type }
+		.field_var { c.comptime_fields_default_type }
+		else { ast.void_type }
+	}
+}
+
 [inline]
 fn (mut c Checker) get_comptime_var_type(node ast.Expr) ast.Type {
 	if node is ast.Ident && (node as ast.Ident).obj is ast.Var {
-		return match (node.obj as ast.Var).ct_type_var {
-			.key_var { c.comptime_fields_key_type }
-			.value_var { c.comptime_fields_val_type }
-			.field_var { c.comptime_fields_default_type }
-			else { ast.void_type }
-		}
+		return c.get_comptime_var_type_from_kind((node.obj as ast.Var).ct_type_var)
 	} else if node is ast.ComptimeSelector {
 		return c.get_comptime_selector_type(node, ast.void_type)
 	} else if node is ast.SelectorExpr && c.is_comptime_selector_type(node as ast.SelectorExpr) {

vlib/v/checker/fn.v

@@ -1325,6 +1325,22 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 	return func.return_type
 }
 
+fn (mut c Checker) get_comptime_args(node_ ast.CallExpr) map[int]ast.Type {
+	mut comptime_args := map[int]ast.Type{}
+	for i, call_arg in node_.args {
+		if call_arg.expr is ast.Ident {
+			if call_arg.expr.obj is ast.Var {
+				if call_arg.expr.obj.ct_type_var != .no_comptime {
+					comptime_args[i] = c.get_comptime_var_type_from_kind(call_arg.expr.obj.ct_type_var)
+				}
+			}
+		} else if call_arg.expr is ast.ComptimeSelector && c.is_comptime_var(call_arg.expr) {
+			comptime_args[i] = c.get_comptime_var_type(call_arg.expr)
+		}
+	}
+	return comptime_args
+}
+
 fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 	left_type := c.expr(node.left)
 	if left_type == ast.void_type {
@@ -1518,8 +1534,26 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 				concrete_types << concrete_type
 			}
 		}
+		if c.inside_comptime_for_field && concrete_types.len > 0 {
+			mut comptime_args := c.get_comptime_args(node)
+			mut comptime_types := concrete_types.clone()
+			for k, v in comptime_args {
+				arg_sym := c.table.sym(v)
+				if method.generic_names.len > 0 && arg_sym.kind == .array
+					&& method.params[k + 1].typ.has_flag(.generic)
+					&& c.table.final_sym(method.params[k + 1].typ).kind == .array {
+					comptime_types[k] = (arg_sym.info as ast.Array).elem_type
+				} else {
+					comptime_types[k] = v
+				}
+			}
+			if comptime_args.len > 0
+				&& c.table.register_fn_concrete_types(method.fkey(), comptime_types) {
+				c.need_recheck_generic_fns = true
+			}
+		}
 		if concrete_types.len > 0 {
-			if c.table.register_fn_concrete_types(node.fkey(), concrete_types) {
+			if c.table.register_fn_concrete_types(method.fkey(), concrete_types) {
 				c.need_recheck_generic_fns = true
 			}
 		}
@@ -1582,11 +1616,6 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 		}
 
 		for i, mut arg in node.args {
-			param_idx := if method.is_variadic && i >= method.params.len - 1 {
-				method.params.len - 1
-			} else {
-				i + 1
-			}
 			if i > 0 || exp_arg_typ == ast.Type(0) {
 				exp_arg_typ = if method.is_variadic && i >= method.params.len - 1 {
 					method.params.last().typ
@@ -1601,32 +1630,6 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 
 			mut got_arg_typ := c.check_expr_opt_call(arg.expr, c.expr(arg.expr))
 			node.args[i].typ = got_arg_typ
-			if c.inside_comptime_for_field && method.params[param_idx].typ.has_flag(.generic) {
-				arg_sym := c.table.sym(c.comptime_fields_default_type)
-				if arg_sym.kind == .array
-					&& c.table.sym(method.params[param_idx].typ).kind == .array {
-					if c.table.register_fn_concrete_types(method.fkey(), [
-						(arg_sym.info as ast.Array).elem_type,
-					])
-					{
-						c.need_recheck_generic_fns = true
-					}
-				} else {
-					if c.table.register_fn_concrete_types(method.fkey(), [
-						c.comptime_fields_default_type,
-					])
-					{
-						c.need_recheck_generic_fns = true
-					}
-				}
-			} else if c.inside_for_in_any_cond && method.params[param_idx].typ.has_flag(.generic) {
-				if c.table.register_fn_concrete_types(method.fkey(), [
-					c.for_in_any_val_type,
-				])
-				{
-					c.need_recheck_generic_fns = true
-				}
-			}
 			if no_type_promotion {
 				if got_arg_typ != exp_arg_typ {
 					c.error('cannot use `${c.table.sym(got_arg_typ).name}` as argument for `${method.name}` (`${exp_arg_sym.name}` expected)',

vlib/v/checker/for.v

@@ -167,9 +167,6 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 				c.comptime_fields_val_type = value_type
 				node.scope.update_ct_var_kind(node.val_var, .value_var)
 			}
-
-			c.inside_for_in_any_cond = true
-			c.for_in_any_val_type = value_type
 		} else {
 			if sym.kind == .map && !(node.key_var.len > 0 && node.val_var.len > 0) {
 				c.error(
@@ -246,8 +243,6 @@ fn (mut c Checker) for_in_stmt(mut node ast.ForInStmt) {
 	c.check_loop_label(node.label, node.pos)
 	c.stmts(node.stmts)
 	c.loop_label = prev_loop_label
-	c.inside_for_in_any_cond = false
-	c.for_in_any_val_type = 0
 	c.in_for_count--
 }
 

vlib/v/tests/comptime_concrete_type_register_test.v

@@ -0,0 +1,79 @@
+struct Encoder {}
+
+struct StructType[T] {
+mut:
+	val T
+}
+
+fn encode_struct[U](val U) ! {
+	$for field in U.fields {
+		$if field.typ is $Map {
+			for _, v in val.$(field.name) {
+				encode_value_with_level(v)!
+			}
+		}
+	}
+}
+
+fn encode_value_with_level[T](val T) ! {
+	$if T is $Struct {
+		dump(val)
+		println(encode_struct(val)!)
+	} $else $if T is $Map {
+		dump(val)
+	} $else $if T is string {
+		dump(val)
+	}
+}
+
+fn (e &Encoder) encode_struct[U](val U) ! {
+	$for field in U.fields {
+		$if field.typ is $Map {
+			for _, v in val.$(field.name) {
+				e.encode_value_with_level(v)!
+			}
+		}
+	}
+}
+
+fn (e &Encoder) encode_value_with_level[T](val T) ! {
+	$if T is $Struct {
+		dump(val)
+		println(e.encode_struct(val)!)
+	} $else $if T is $Map {
+		dump(val)
+	} $else $if T is string {
+		dump(val)
+	}
+}
+
+fn test_method() ! {
+	e := Encoder{}
+	e.encode_struct(StructType[map[string]map[string]int]{
+		val: {
+			'1': {
+				'val': 1
+			}
+		}
+	})!
+	e.encode_struct(StructType[map[string]string]{
+		val: {
+			'1': '1'
+		}
+	})!
+}
+
+fn test_func() ! {
+	encode_struct(StructType[map[string]map[string]int]{
+		val: {
+			'1': {
+				'val': 1
+			}
+		}
+	})!
+	encode_struct(StructType[map[string]string]{
+		val: {
+			'1': '1'
+		}
+	})!
+}