type_resolver: refactor resolve_comptime_type (#23616)

felipensp · web-flow · commit 78effd0c092d · 2025-01-31T08:51:20.000+02:00
diff --git a/cmd/tools/vast/vast.v b/cmd/tools/vast/vast.v
@@ -1453,6 +1453,7 @@ fn (t Tree) selector_expr(node ast.SelectorExpr) &Node {
 	obj.add_terse('from_embed_types', t.array_node_type(node.from_embed_types))
 	obj.add_terse('has_hidden_receiver', t.bool_node(node.has_hidden_receiver))
 	obj.add_terse('next_token', t.token_node(node.next_token))
+	obj.add_terse('is_field_typ', t.bool_node(node.is_field_typ))
 	obj.add('pos', t.pos(node.pos))
 	obj.add('scope', t.number_node(int(node.scope)))
 	return obj
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
@@ -311,6 +311,7 @@ pub mut:
 	from_embed_types         []Type   // holds the type of the embed that the method is called from
 	generic_from_embed_types [][]Type // holds the types of the embeds for each generic instance when the same generic method is called.
 	has_hidden_receiver      bool
+	is_field_typ             bool // var.typ for comptime $for var
 }
 
 // root_ident returns the origin ident where the selector started.
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -1645,6 +1645,7 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
 			return node.expr_type
 		}
 	}
+	node.is_field_typ = node.is_field_typ || c.comptime.is_comptime_selector_type(node)
 	old_selector_expr := c.inside_selector_expr
 	c.inside_selector_expr = true
 	mut typ := c.expr(mut node.expr)
diff --git a/vlib/v/gen/c/assert.v b/vlib/v/gen/c/assert.v
@@ -151,12 +151,12 @@ fn (mut g Gen) gen_assert_metainfo(node ast.AssertStmt, kind AssertMetainfoKind)
 			g.writeln('\t${metaname}.op = ${expr_op_str};')
 			g.writeln('\t${metaname}.llabel = ${expr_left_str};')
 			g.writeln('\t${metaname}.rlabel = ${expr_right_str};')
-			left_type := if g.comptime.is_comptime_expr(node.expr.left) {
-				g.type_resolver.get_type(node.expr.left)
+			left_type := if node.expr.left_ct_expr {
+				g.type_resolver.get_type_or_default(node.expr.left, node.expr.left_type)
 			} else {
 				node.expr.left_type
 			}
-			right_type := if g.comptime.is_comptime_expr(node.expr.right) {
+			right_type := if node.expr.right_ct_expr {
 				g.type_resolver.get_type(node.expr.right)
 			} else {
 				node.expr.right_type
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -3584,7 +3584,7 @@ fn (mut g Gen) expr(node_ ast.Expr) {
 			}
 		}
 		ast.IsRefType {
-			typ := g.resolve_comptime_type(node.expr, g.get_type(node.typ))
+			typ := g.type_resolver.typeof_type(node.expr, g.get_type(node.typ))
 			node_typ := g.unwrap_generic(typ)
 			sym := g.table.sym(node_typ)
 			if sym.language == .v && sym.kind in [.placeholder, .any] {
@@ -3669,7 +3669,7 @@ fn (mut g Gen) expr(node_ ast.Expr) {
 				g.writeln2('\tpanic_option_not_set(_SLIT("none"));', '}')
 				g.write(cur_line)
 				if is_unwrapped {
-					typ := g.resolve_comptime_type(node.expr, node.typ)
+					typ := g.type_resolver.typeof_type(node.expr, node.typ)
 					g.write('*(${g.base_type(typ)}*)&')
 					g.expr(node.expr)
 					g.write('.data')
@@ -3844,7 +3844,7 @@ fn (mut g Gen) type_name(raw_type ast.Type) {
 }
 
 fn (mut g Gen) typeof_expr(node ast.TypeOf) {
-	typ := g.resolve_comptime_type(node.expr, g.get_type(node.typ))
+	typ := g.type_resolver.typeof_type(node.expr, g.get_type(node.typ))
 	sym := g.table.sym(typ)
 	if sym.kind == .sum_type {
 		// When encountering a .sum_type, typeof() should be done at runtime,
@@ -3894,30 +3894,30 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {
 					// typeof(expr).name
 					mut name_type := node.name_type
 					if node.expr is ast.TypeOf {
-						name_type = g.resolve_comptime_type(node.expr.expr, name_type)
+						name_type = g.type_resolver.typeof_type(node.expr.expr, name_type)
 					}
 					g.type_name(name_type)
 					return
 				} else if node.field_name == 'idx' {
 					mut name_type := node.name_type
 					if node.expr is ast.TypeOf {
-						name_type = g.resolve_comptime_type(node.expr.expr, name_type)
+						name_type = g.type_resolver.typeof_type(node.expr.expr, name_type)
 					}
 					// `typeof(expr).idx`
 					g.write(int(g.unwrap_generic(name_type)).str())
 					return
 				} else if node.field_name == 'unaliased_typ' {
 					mut name_type := node.name_type
 					if node.expr is ast.TypeOf {
-						name_type = g.resolve_comptime_type(node.expr.expr, name_type)
+						name_type = g.type_resolver.typeof_type(node.expr.expr, name_type)
 					}
 					// `typeof(expr).unaliased_typ`
 					g.write(int(g.table.unaliased_type(g.unwrap_generic(name_type))).str())
 					return
 				} else if node.field_name == 'indirections' {
 					mut name_type := node.name_type
 					if node.expr is ast.TypeOf {
-						name_type = g.resolve_comptime_type(node.expr.expr, name_type)
+						name_type = g.type_resolver.typeof_type(node.expr.expr, name_type)
 					}
 					// `typeof(expr).indirections`
 					g.write(int(g.unwrap_generic(name_type).nr_muls()).str())
@@ -5224,7 +5224,7 @@ fn (mut g Gen) cast_expr(node ast.CastExpr) {
 	node_typ := g.unwrap_generic(node.typ)
 	mut expr_type := node.expr_type
 	sym := g.table.sym(node_typ)
-	if g.comptime.is_comptime_expr(node.expr) {
+	if g.comptime.is_comptime(node.expr) {
 		expr_type = g.unwrap_generic(g.type_resolver.get_type(node.expr))
 	}
 	node_typ_is_option := node.typ.has_flag(.option)
@@ -7231,7 +7231,7 @@ fn (mut g Gen) get_type(typ ast.Type) ast.Type {
 }
 
 fn (mut g Gen) size_of(node ast.SizeOf) {
-	typ := g.resolve_comptime_type(node.expr, g.get_type(node.typ))
+	typ := g.type_resolver.typeof_type(node.expr, g.get_type(node.typ))
 	node_typ := g.unwrap_generic(typ)
 	sym := g.table.sym(node_typ)
 	if sym.language == .v && sym.kind in [.placeholder, .any] {
diff --git a/vlib/v/gen/c/comptime.v b/vlib/v/gen/c/comptime.v
@@ -801,21 +801,6 @@ fn (mut g Gen) pop_comptime_info() {
 	g.comptime.comptime_for_method_ret_type = old.comptime_for_method_ret_type
 }
 
-fn (mut g Gen) resolve_comptime_type(node ast.Expr, default_type ast.Type) ast.Type {
-	if g.comptime.is_comptime_expr(node) {
-		return g.type_resolver.get_type(node)
-	} else if node is ast.SelectorExpr && node.expr_type != 0 {
-		if node.expr is ast.Ident && g.comptime.is_comptime_selector_type(node) {
-			return g.type_resolver.get_type_from_comptime_var(node.expr)
-		}
-		sym := g.table.sym(g.unwrap_generic(node.expr_type))
-		if f := g.table.find_field_with_embeds(sym, node.field_name) {
-			return f.typ
-		}
-	}
-	return default_type
-}
-
 fn (mut g Gen) comptime_for(node ast.ComptimeFor) {
 	sym := if node.typ != g.field_data_type {
 		g.table.final_sym(g.unwrap_generic(node.typ))
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
@@ -1324,7 +1324,7 @@ fn (mut g Gen) gen_to_str_method_call(node ast.CallExpr) bool {
 			return true
 		}
 	} else if left_node is ast.PostfixExpr {
-		rec_type = g.resolve_comptime_type(left_node.expr, rec_type)
+		rec_type = g.type_resolver.get_type_or_default(left_node.expr, rec_type)
 		if left_node.op == .question {
 			rec_type = rec_type.clear_flag(.option)
 		}
diff --git a/vlib/v/type_resolver/comptime_resolver.v b/vlib/v/type_resolver/comptime_resolver.v
@@ -75,6 +75,22 @@ pub fn (t &ResolverInfo) is_comptime_variant_var(node ast.Ident) bool {
 	return node.name == t.comptime_for_variant_var
 }
 
+// typeof_type resolves type for typeof() expr where field.typ is resolved to real type instead of int type to make type(field.typ).name working
+pub fn (mut t TypeResolver) typeof_type(node ast.Expr, default_type ast.Type) ast.Type {
+	if t.info.is_comptime(node) {
+		return t.get_type(node)
+	} else if node is ast.SelectorExpr && node.expr_type != 0 {
+		if node.expr is ast.Ident && node.is_field_typ {
+			return t.get_type_from_comptime_var(node.expr)
+		}
+		sym := t.table.sym(t.resolver.unwrap_generic(node.expr_type))
+		if f := t.table.find_field_with_embeds(sym, node.field_name) {
+			return f.typ
+		}
+	}
+	return default_type
+}
+
 // get_ct_type_var gets the comptime type of the variable (.generic_param, .key_var, etc)
 @[inline]
 pub fn (t &ResolverInfo) get_ct_type_var(node ast.Expr) ast.ComptimeVarKind {
diff --git a/vlib/v/type_resolver/type_resolver.v b/vlib/v/type_resolver/type_resolver.v
@@ -207,7 +207,7 @@ pub fn (mut t TypeResolver) get_type(node ast.Expr) ast.Type {
 		}
 		return ctyp
 	} else if node is ast.SelectorExpr {
-		if t.info.is_comptime_selector_type(node) {
+		if node.is_field_typ {
 			return t.get_type_from_comptime_var(node.expr as ast.Ident)
 		}
 		if node.expr is ast.Ident && node.expr.ct_expr {
@@ -216,8 +216,18 @@ pub fn (mut t TypeResolver) get_type(node ast.Expr) ast.Type {
 			// Struct[T] can have field with generic type
 			if struct_sym.info is ast.Struct && struct_sym.info.generic_types.len > 0 {
 				if field := t.table.find_field(struct_sym, node.field_name) {
+					if f_unwrap := node.scope.find_struct_field(ast.Expr(node.expr).str(),
+						t.get_type_or_default(node.expr, node.expr_type), node.field_name)
+					{
+						return f_unwrap.smartcasts.last()
+					}
 					return field.typ
 				}
+			} else {
+				sym := t.table.sym(t.resolver.unwrap_generic(node.expr_type))
+				if f := t.table.find_field_with_embeds(sym, node.field_name) {
+					return f.typ
+				}
 			}
 		}
 		return node.typ

Original file line number	Diff line number	Diff line change
`@@ -311,6 +311,7 @@ pub mut:`
`311`	`311`	`from_embed_types []Type // holds the type of the embed that the method is called from`
`312`	`312`	`generic_from_embed_types [][]Type // holds the types of the embeds for each generic instance when the same generic method is called.`
`313`	`313`	`has_hidden_receiver bool`
	`314`	`+ is_field_typ bool // var.typ for comptime $for var`
`314`	`315`	`}`
`315`	`316`
`316`	`317`	`// root_ident returns the origin ident where the selector started.`
Original file line number	Diff line number	Diff line change
`@@ -1645,6 +1645,7 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {`
`1645`	`1645`	`return node.expr_type`
`1646`	`1646`	`}`
`1647`	`1647`	`}`
	`1648`	`+ node.is_field_typ = node.is_field_typ \|\| c.comptime.is_comptime_selector_type(node)`
`1648`	`1649`	`old_selector_expr := c.inside_selector_expr`
`1649`	`1650`	`c.inside_selector_expr = true`
`1650`	`1651`	`mut typ := c.expr(mut node.expr)`
Original file line number	Diff line number	Diff line change
`@@ -1324,7 +1324,7 @@ fn (mut g Gen) gen_to_str_method_call(node ast.CallExpr) bool {`
`1324`	`1324`	`return true`
`1325`	`1325`	`}`
`1326`	`1326`	`} else if left_node is ast.PostfixExpr {`
`1327`		`- rec_type = g.resolve_comptime_type(left_node.expr, rec_type)`
	`1327`	`+ rec_type = g.type_resolver.get_type_or_default(left_node.expr, rec_type)`
`1328`	`1328`	`if left_node.op == .question {`
`1329`	`1329`	`rec_type = rec_type.clear_flag(.option)`
`1330`	`1330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ pub fn (mut t TypeResolver) get_type(node ast.Expr) ast.Type {`
`207`	`207`	`}`
`208`	`208`	`return ctyp`
`209`	`209`	`} else if node is ast.SelectorExpr {`
`210`		`- if t.info.is_comptime_selector_type(node) {`
	`210`	`+ if node.is_field_typ {`
`211`	`211`	`return t.get_type_from_comptime_var(node.expr as ast.Ident)`
`212`	`212`	`}`
`213`	`213`	`if node.expr is ast.Ident && node.expr.ct_expr {`
`@@ -216,8 +216,18 @@ pub fn (mut t TypeResolver) get_type(node ast.Expr) ast.Type {`
`216`	`216`	`// Struct[T] can have field with generic type`
`217`	`217`	`if struct_sym.info is ast.Struct && struct_sym.info.generic_types.len > 0 {`
`218`	`218`	`if field := t.table.find_field(struct_sym, node.field_name) {`
	`219`	`+ if f_unwrap := node.scope.find_struct_field(ast.Expr(node.expr).str(),`
	`220`	`+ t.get_type_or_default(node.expr, node.expr_type), node.field_name)`
	`221`	`+ {`
	`222`	`+ return f_unwrap.smartcasts.last()`
	`223`	`+ }`
`219`	`224`	`return field.typ`
`220`	`225`	`}`
	`226`	`+ } else {`
	`227`	`+ sym := t.table.sym(t.resolver.unwrap_generic(node.expr_type))`
	`228`	`+ if f := t.table.find_field_with_embeds(sym, node.field_name) {`
	`229`	`+ return f.typ`
	`230`	`+ }`
`221`	`231`	`}`
`222`	`232`	`}`
`223`	`233`	`return node.typ`