ast: minimise allocations done for the common case in find_struct_field

spytheman · spytheman · commit a9ff1a26244c · 2025-04-07T10:14:34.000+03:00
diff --git a/vlib/v/ast/scope.v b/vlib/v/ast/scope.v
@@ -61,21 +61,23 @@ pub fn (s &Scope) find(name string) ?ScopeObject {
 }
 
 // selector_expr:  name.field_name
-pub fn (s &Scope) find_struct_field(name string, struct_type Type, field_name string) ?ScopeStructField {
+pub fn (s &Scope) find_struct_field(name string, struct_type Type, field_name string) &ScopeStructField {
 	if s == unsafe { nil } {
-		return none
+		return unsafe { nil }
 	}
 	for sc := unsafe { s }; true; sc = sc.parent {
 		if field := sc.struct_fields[name] {
 			if field.struct_type == struct_type && field.name == field_name {
-				return field
+				return &ScopeStructField{
+					...field
+				}
 			}
 		}
 		if sc.dont_lookup_parent() {
 			break
 		}
 	}
-	return none
+	return unsafe { nil }
 }
 
 pub fn (s &Scope) find_var(name string) ?&Var {
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -1794,7 +1794,8 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
 		}
 		if field_sym.kind in [.sum_type, .interface] || field.typ.has_flag(.option) {
 			if !prevent_sum_type_unwrapping_once {
-				if scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name) {
+				scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name)
+				if scope_field != unsafe { nil } {
 					return scope_field.smartcasts.last()
 				}
 			}
@@ -4379,7 +4380,8 @@ fn (mut c Checker) smartcast(mut expr ast.Expr, cur_type ast.Type, to_type_ ast.
 				}
 			}
 			expr_str := expr.expr.str()
-			if mut field := scope.find_struct_field(expr_str, expr.expr_type, expr.field_name) {
+			field := scope.find_struct_field(expr_str, expr.expr_type, expr.field_name)
+			if field != unsafe { nil } {
 				smartcasts << field.smartcasts
 			}
 			// smartcast either if the value is immutable or if the mut argument is explicitly given
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -2164,9 +2164,9 @@ fn (mut c Checker) method_call(mut node ast.CallExpr, mut continue_check &bool)
 			mut field_typ := field.typ
 			if field.typ.has_flag(.option) {
 				// unwrapped callback (if f.func != none {})
-				if scope_field := node.scope.find_struct_field(node.left.str(), node.left_type,
+				scope_field := node.scope.find_struct_field(node.left.str(), node.left_type,
 					method_name)
-				{
+				if scope_field != unsafe { nil } {
 					field_typ = scope_field.smartcasts.last()
 					node.is_unwrapped_fn_selector = true
 				} else {
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -3008,7 +3008,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_typ
 					}
 				}
 			} else if expr is ast.SelectorExpr {
-				if v := scope.find_struct_field(expr.expr.str(), expr.expr_type, expr.field_name) {
+				v := scope.find_struct_field(expr.expr.str(), expr.expr_type, expr.field_name)
+				if v != unsafe { nil } {
 					if v.smartcasts.len > 0 && unwrapped_expected_type == v.orig_type {
 						is_already_sum_type = true
 					}
@@ -4178,7 +4179,8 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {
 			if !prevent_sum_type_unwrapping_once {
 				// check first if field is sum type because scope searching is expensive
 				scope := g.file.scope.innermost(node.pos.pos)
-				if field := scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name) {
+				field := scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name)
+				if field != unsafe { nil } {
 					nested_unwrap := is_option && field.smartcasts.len > 1
 					is_option_unwrap = is_option && field.smartcasts.len > 0
 						&& field.typ.clear_flag(.option) == field.smartcasts.last()
diff --git a/vlib/v/gen/c/comptime.v b/vlib/v/gen/c/comptime.v
@@ -1125,7 +1125,8 @@ fn (mut g Gen) comptime_selector_type(node ast.SelectorExpr) ast.Type {
 		field_sym := g.table.sym(field.typ)
 		if field_sym.kind in [.sum_type, .interface] {
 			if !prevent_sum_type_unwrapping_once {
-				if scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name) {
+				scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name)
+				if scope_field != unsafe { nil } {
 					return scope_field.smartcasts.last()
 				}
 			}
diff --git a/vlib/v/type_resolver/comptime_resolver.v b/vlib/v/type_resolver/comptime_resolver.v
@@ -75,7 +75,8 @@ pub fn (mut t TypeResolver) typeof_type(node ast.Expr, default_type ast.Type) as
 		if node.expr is ast.Ident && node.is_field_typ {
 			return t.get_type_from_comptime_var(node.expr)
 		}
-		if field := node.scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name) {
+		field := node.scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name)
+		if field != unsafe { nil } {
 			if field.smartcasts.len > 0 {
 				return field.smartcasts.last()
 			}
diff --git a/vlib/v/type_resolver/type_resolver.v b/vlib/v/type_resolver/type_resolver.v
@@ -234,9 +234,9 @@ 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(),
+					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)
-					{
+					if f_unwrap != unsafe { nil } {
 						return f_unwrap.smartcasts.last()
 					}
 					return field.typ

Original file line number	Diff line number	Diff line change
`@@ -61,21 +61,23 @@ pub fn (s &Scope) find(name string) ?ScopeObject {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`// selector_expr: name.field_name`
`64`		`-pub fn (s &Scope) find_struct_field(name string, struct_type Type, field_name string) ?ScopeStructField {`
	`64`	`+pub fn (s &Scope) find_struct_field(name string, struct_type Type, field_name string) &ScopeStructField {`
`65`	`65`	`if s == unsafe { nil } {`
`66`		`- return none`
	`66`	`+ return unsafe { nil }`
`67`	`67`	`}`
`68`	`68`	`for sc := unsafe { s }; true; sc = sc.parent {`
`69`	`69`	`if field := sc.struct_fields[name] {`
`70`	`70`	`if field.struct_type == struct_type && field.name == field_name {`
`71`		`- return field`
	`71`	`+ return &ScopeStructField{`
	`72`	`+ ...field`
	`73`	`+ }`
`72`	`74`	`}`
`73`	`75`	`}`
`74`	`76`	`if sc.dont_lookup_parent() {`
`75`	`77`	`break`
`76`	`78`	`}`
`77`	`79`	`}`
`78`		`- return none`
	`80`	`+ return unsafe { nil }`
`79`	`81`	`}`
`80`	`82`
`81`	`83`	`pub fn (s &Scope) find_var(name string) ?&Var {`
Original file line number	Diff line number	Diff line change
`@@ -1794,7 +1794,8 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {`
`1794`	`1794`	`}`
`1795`	`1795`	`if field_sym.kind in [.sum_type, .interface] \|\| field.typ.has_flag(.option) {`
`1796`	`1796`	`if !prevent_sum_type_unwrapping_once {`
`1797`		`- if scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name) {`
	`1797`	`+ scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name)`
	`1798`	`+ if scope_field != unsafe { nil } {`
`1798`	`1799`	`return scope_field.smartcasts.last()`
`1799`	`1800`	`}`
`1800`	`1801`	`}`
`@@ -4379,7 +4380,8 @@ fn (mut c Checker) smartcast(mut expr ast.Expr, cur_type ast.Type, to_type_ ast.`
`4379`	`4380`	`}`
`4380`	`4381`	`}`
`4381`	`4382`	`expr_str := expr.expr.str()`
`4382`		`- if mut field := scope.find_struct_field(expr_str, expr.expr_type, expr.field_name) {`
	`4383`	`+ field := scope.find_struct_field(expr_str, expr.expr_type, expr.field_name)`
	`4384`	`+ if field != unsafe { nil } {`
`4383`	`4385`	`smartcasts << field.smartcasts`
`4384`	`4386`	`}`
`4385`	`4387`	`// smartcast either if the value is immutable or if the mut argument is explicitly given`
Original file line number	Diff line number	Diff line change
`@@ -3008,7 +3008,8 @@ fn (mut g Gen) expr_with_cast(expr ast.Expr, got_type_raw ast.Type, expected_typ`
`3008`	`3008`	`}`
`3009`	`3009`	`}`
`3010`	`3010`	`} else if expr is ast.SelectorExpr {`
`3011`		`- if v := scope.find_struct_field(expr.expr.str(), expr.expr_type, expr.field_name) {`
	`3011`	`+ v := scope.find_struct_field(expr.expr.str(), expr.expr_type, expr.field_name)`
	`3012`	`+ if v != unsafe { nil } {`
`3012`	`3013`	`if v.smartcasts.len > 0 && unwrapped_expected_type == v.orig_type {`
`3013`	`3014`	`is_already_sum_type = true`
`3014`	`3015`	`}`
`@@ -4178,7 +4179,8 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {`
`4178`	`4179`	`if !prevent_sum_type_unwrapping_once {`
`4179`	`4180`	`// check first if field is sum type because scope searching is expensive`
`4180`	`4181`	`scope := g.file.scope.innermost(node.pos.pos)`
`4181`		`- if field := scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name) {`
	`4182`	`+ field := scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name)`
	`4183`	`+ if field != unsafe { nil } {`
`4182`	`4184`	`nested_unwrap := is_option && field.smartcasts.len > 1`
`4183`	`4185`	`is_option_unwrap = is_option && field.smartcasts.len > 0`
`4184`	`4186`	`&& field.typ.clear_flag(.option) == field.smartcasts.last()`
Original file line number	Diff line number	Diff line change
`@@ -1125,7 +1125,8 @@ fn (mut g Gen) comptime_selector_type(node ast.SelectorExpr) ast.Type {`
`1125`	`1125`	`field_sym := g.table.sym(field.typ)`
`1126`	`1126`	`if field_sym.kind in [.sum_type, .interface] {`
`1127`	`1127`	`if !prevent_sum_type_unwrapping_once {`
`1128`		`- if scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name) {`
	`1128`	`+ scope_field := node.scope.find_struct_field(node.expr.str(), typ, field_name)`
	`1129`	`+ if scope_field != unsafe { nil } {`
`1129`	`1130`	`return scope_field.smartcasts.last()`
`1130`	`1131`	`}`
`1131`	`1132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,8 @@ pub fn (mut t TypeResolver) typeof_type(node ast.Expr, default_type ast.Type) as`
`75`	`75`	`if node.expr is ast.Ident && node.is_field_typ {`
`76`	`76`	`return t.get_type_from_comptime_var(node.expr)`
`77`	`77`	`}`
`78`		`- if field := node.scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name) {`
	`78`	`+ field := node.scope.find_struct_field(node.expr.str(), node.expr_type, node.field_name)`
	`79`	`+ if field != unsafe { nil } {`
`79`	`80`	`if field.smartcasts.len > 0 {`
`80`	`81`	`return field.smartcasts.last()`
`81`	`82`	`}`