v: cleanup if smartcasts in the compiler (#24734)

felipensp · web-flow · commit e14853d6e069 · 2025-06-17T18:49:49.000+03:00
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
@@ -2594,10 +2594,8 @@ pub fn (mut lx IndexExpr) recursive_arraymap_set_is_setter() {
 	lx.is_setter = true
 	if mut lx.left is IndexExpr {
 		lx.left.recursive_arraymap_set_is_setter()
-	} else if mut lx.left is SelectorExpr {
-		if mut lx.left.expr is IndexExpr {
-			lx.left.expr.recursive_arraymap_set_is_setter()
-		}
+	} else if mut lx.left is SelectorExpr && lx.left.expr is IndexExpr {
+		lx.left.expr.recursive_arraymap_set_is_setter()
 	}
 }
 
diff --git a/vlib/v/checker/assign.v b/vlib/v/checker/assign.v
@@ -103,10 +103,8 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 			c.error('cannot assign a `none` value to a variable', right.pos)
 		}
 		// Handle `left_name := unsafe { none }`
-		if mut right is ast.UnsafeExpr {
-			if mut right.expr is ast.None {
-				c.error('cannot use `none` in `unsafe` blocks', right.expr.pos)
-			}
+		if mut right is ast.UnsafeExpr && right.expr is ast.None {
+			c.error('cannot use `none` in `unsafe` blocks', right.expr.pos)
 		}
 		if mut right is ast.AnonFn {
 			if right.decl.generic_names.len > 0 {
@@ -159,11 +157,9 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 				c.error('cannot dereference a function call on the left side of an assignment, use a temporary variable',
 					left.pos)
 			}
-		} else if mut left is ast.IndexExpr {
-			if left.index is ast.RangeExpr {
-				c.error('cannot reassign using range expression on the left side of an assignment',
-					left.pos)
-			}
+		} else if mut left is ast.IndexExpr && left.index is ast.RangeExpr {
+			c.error('cannot reassign using range expression on the left side of an assignment',
+				left.pos)
 		} else if mut left is ast.Ident && node.op == .decl_assign {
 			if left.name in c.global_names {
 				c.note('the global variable named `${left.name}` already exists', left.pos)
@@ -199,10 +195,8 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 		}
 		if node.right_types.len < node.left.len { // first type or multi return types added above
 			old_inside_ref_lit := c.inside_ref_lit
-			if mut left is ast.Ident {
-				if mut left.info is ast.IdentVar {
-					c.inside_ref_lit = c.inside_ref_lit || left.info.share == .shared_t
-				}
+			if mut left is ast.Ident && left.info is ast.IdentVar {
+				c.inside_ref_lit = c.inside_ref_lit || left.info.share == .shared_t
 			}
 			c.inside_decl_rhs = is_decl
 			mut expr := node.right[i]
@@ -666,11 +660,9 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 				}
 			}
 		}
-		if mut left is ast.Ident {
-			if mut left.info is ast.IdentVar {
-				if left.info.is_static && right_sym.kind == .map {
-					c.error('maps cannot be static', left.pos)
-				}
+		if mut left is ast.Ident && left.info is ast.IdentVar {
+			if left.info.is_static && right_sym.kind == .map {
+				c.error('maps cannot be static', left.pos)
 			}
 		}
 		// Single side check
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -911,10 +911,8 @@ fn (mut c Checker) fail_if_immutable(mut expr ast.Expr) (string, token.Pos) {
 		}
 		ast.ComptimeSelector {
 			mut expr_left := expr.left
-			if mut expr.left is ast.Ident {
-				if mut expr.left.obj is ast.Var {
-					c.fail_if_immutable(mut expr_left)
-				}
+			if mut expr.left is ast.Ident && expr.left.obj is ast.Var {
+				c.fail_if_immutable(mut expr_left)
 			}
 			return '', expr.pos
 		}
@@ -1117,6 +1115,9 @@ fn (mut c Checker) fail_if_immutable(mut expr ast.Expr) (string, token.Pos) {
 			}
 			return '', expr.pos
 		}
+		ast.AsCast {
+			to_lock, pos = c.fail_if_immutable(mut expr.expr)
+		}
 		else {
 			if !expr.is_pure_literal() {
 				c.error('unexpected expression `${expr.type_name()}`', expr.pos())
@@ -1678,10 +1679,8 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
 	c.inside_selector_expr = true
 	mut typ := c.expr(mut node.expr)
 	if node.expr.is_auto_deref_var() {
-		if mut node.expr is ast.Ident {
-			if mut node.expr.obj is ast.Var {
-				typ = node.expr.obj.typ
-			}
+		if mut node.expr is ast.Ident && node.expr.obj is ast.Var {
+			typ = node.expr.obj.typ
 		}
 	}
 	c.inside_selector_expr = old_selector_expr
@@ -4417,10 +4416,8 @@ fn (mut c Checker) smartcast(mut expr ast.Expr, cur_type ast.Type, to_type_ ast.
 				}
 			}
 			mut expr_str := expr.expr.str()
-			if mut expr.expr is ast.ParExpr {
-				if mut expr.expr.expr is ast.AsCast {
-					expr_str = expr.expr.expr.expr.str()
-				}
+			if mut expr.expr is ast.ParExpr && expr.expr.expr is ast.AsCast {
+				expr_str = expr.expr.expr.expr.str()
 			}
 			field := scope.find_struct_field(expr_str, expr.expr_type, expr.field_name)
 			if field != unsafe { nil } {
@@ -5058,15 +5055,12 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {
 		|| typ.is_pointer() {
 		mut is_ok := false
 		mut is_mut_struct := false
-		if mut node.left is ast.Ident {
-			if mut node.left.obj is ast.Var {
-				// `mut param []T` function parameter
-				is_ok = node.left.obj.is_mut && node.left.obj.is_arg && !typ.deref().is_ptr()
-					&& typ_sym.kind != .struct
-				// `mut param Struct`
-				is_mut_struct = node.left.obj.is_mut && node.left.obj.is_arg
-					&& typ_sym.kind == .struct
-			}
+		if mut node.left is ast.Ident && node.left.obj is ast.Var {
+			// `mut param []T` function parameter
+			is_ok = node.left.obj.is_mut && node.left.obj.is_arg && !typ.deref().is_ptr()
+				&& typ_sym.kind != .struct
+			// `mut param Struct`
+			is_mut_struct = node.left.obj.is_mut && node.left.obj.is_arg && typ_sym.kind == .struct
 		}
 		if !is_ok && node.index is ast.RangeExpr {
 			s := c.table.type_to_str(typ)
diff --git a/vlib/v/checker/containers.v b/vlib/v/checker/containers.v
@@ -799,10 +799,8 @@ fn (mut c Checker) check_append(mut node ast.InfixExpr, left_type ast.Type, righ
 	right := node.right
 	if right is ast.PrefixExpr && right.op == .amp {
 		mut expr2 := right.right
-		if mut expr2 is ast.Ident {
-			if !node.left.is_blank_ident() && expr2.obj is ast.ConstField {
-				c.error('cannot have mutable reference to const `${expr2.name}`', expr2.pos)
-			}
+		if mut expr2 is ast.Ident && !node.left.is_blank_ident() && expr2.obj is ast.ConstField {
+			c.error('cannot have mutable reference to const `${expr2.name}`', expr2.pos)
 		}
 	}
 	if left_value_sym.kind == .interface {
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -1520,10 +1520,8 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 		}
 		node.args[i].typ = arg_typ
 		if c.comptime.comptime_for_field_var != '' {
-			if mut call_arg.expr is ast.Ident {
-				if mut call_arg.expr.obj is ast.Var {
-					node.args[i].typ = call_arg.expr.obj.typ
-				}
+			if mut call_arg.expr is ast.Ident && call_arg.expr.obj is ast.Var {
+				node.args[i].typ = call_arg.expr.obj.typ
 			}
 		}
 		arg_typ_sym := c.table.sym(arg_typ)
diff --git a/vlib/v/checker/for.v b/vlib/v/checker/for.v
@@ -318,13 +318,11 @@ fn (mut c Checker) for_stmt(mut node ast.ForStmt) {
 			c.error('non-bool used as for condition', node.pos)
 		}
 	}
-	if mut node.cond is ast.InfixExpr {
-		if node.cond.op == .key_is {
-			if node.cond.right is ast.TypeNode && node.cond.left in [ast.Ident, ast.SelectorExpr] {
-				if c.table.type_kind(node.cond.left_type) in [.sum_type, .interface] {
-					c.smartcast(mut node.cond.left, node.cond.left_type, node.cond.right_type, mut
-						node.scope, false, false)
-				}
+	if mut node.cond is ast.InfixExpr && node.cond.op == .key_is {
+		if node.cond.right is ast.TypeNode && node.cond.left in [ast.Ident, ast.SelectorExpr] {
+			if c.table.type_kind(node.cond.left_type) in [.sum_type, .interface] {
+				c.smartcast(mut node.cond.left, node.cond.left_type, node.cond.right_type, mut
+					node.scope, false, false)
 			}
 		}
 	}
diff --git a/vlib/v/checker/match.v b/vlib/v/checker/match.v
@@ -308,10 +308,8 @@ fn (mut c Checker) get_comptime_number_value(mut expr ast.Expr) ?i64 {
 	if mut expr is ast.IntegerLiteral {
 		return expr.val.i64()
 	}
-	if mut expr is ast.CastExpr {
-		if mut expr.expr is ast.IntegerLiteral {
-			return expr.expr.val.i64()
-		}
+	if mut expr is ast.CastExpr && expr.expr is ast.IntegerLiteral {
+		return expr.expr.val.i64()
 	}
 	if mut expr is ast.Ident {
 		if mut obj := c.table.global_scope.find_const(expr.full_name()) {
diff --git a/vlib/v/checker/return.v b/vlib/v/checker/return.v
@@ -82,10 +82,8 @@ fn (mut c Checker) return_stmt(mut node ast.Return) {
 			return
 		}
 		// Handle `return unsafe { none }`
-		if mut expr is ast.UnsafeExpr {
-			if mut expr.expr is ast.None {
-				c.error('cannot return `none` in unsafe block', expr.expr.pos)
-			}
+		if mut expr is ast.UnsafeExpr && expr.expr is ast.None {
+			c.error('cannot return `none` in unsafe block', expr.expr.pos)
 		}
 		if typ == ast.void_type {
 			c.error('`${expr}` used as value', node.pos)
@@ -102,18 +100,16 @@ fn (mut c Checker) return_stmt(mut node ast.Return) {
 				expr_idxs << i
 			}
 		} else {
-			if mut expr is ast.Ident {
-				if mut expr.obj is ast.Var {
-					if expr.obj.smartcasts.len > 0 {
-						typ = c.unwrap_generic(expr.obj.smartcasts.last())
-					}
-					if expr.obj.ct_type_var != .no_comptime {
-						typ = c.type_resolver.get_type_or_default(expr, typ)
-					}
-					if mut expr.obj.expr is ast.IfGuardExpr {
-						if var := expr.scope.find_var(expr.name) {
-							typ = var.typ
-						}
+			if mut expr is ast.Ident && expr.obj is ast.Var {
+				if expr.obj.smartcasts.len > 0 {
+					typ = c.unwrap_generic(expr.obj.smartcasts.last())
+				}
+				if expr.obj.ct_type_var != .no_comptime {
+					typ = c.type_resolver.get_type_or_default(expr, typ)
+				}
+				if mut expr.obj.expr is ast.IfGuardExpr {
+					if var := expr.scope.find_var(expr.name) {
+						typ = var.typ
 					}
 				}
 			}
diff --git a/vlib/v/gen/c/assert.v b/vlib/v/gen/c/assert.v
@@ -231,16 +231,13 @@ fn (mut g Gen) gen_assert_single_expr(expr ast.Expr, typ ast.Type) {
 				&& expr in [ast.IndexExpr, ast.CallExpr, ast.StringLiteral, ast.StringInterLiteral] {
 				should_clone = false
 			}
-			if expr is ast.CTempVar {
-				if expr.orig is ast.CallExpr {
-					should_clone = false
-					if expr.orig.or_block.kind == .propagate_option {
-						should_clone = true
-					}
-					if expr.orig.is_method && expr.orig.args.len == 0
-						&& expr.orig.name == 'type_name' {
-						should_clone = true
-					}
+			if expr is ast.CTempVar && expr.orig is ast.CallExpr {
+				should_clone = false
+				if expr.orig.or_block.kind == .propagate_option {
+					should_clone = true
+				}
+				if expr.orig.is_method && expr.orig.args.len == 0 && expr.orig.name == 'type_name' {
+					should_clone = true
 				}
 			}
 			if should_clone {
diff --git a/vlib/v/gen/c/dumpexpr.v b/vlib/v/gen/c/dumpexpr.v
@@ -34,13 +34,11 @@ fn (mut g Gen) dump_expr(node ast.DumpExpr) {
 	}
 	// var.$(field.name)
 	if node.expr is ast.ComptimeSelector && node.expr.is_name {
-		if node.expr.field_expr is ast.SelectorExpr {
-			if node.expr.field_expr.expr is ast.Ident {
-				if node.expr.field_expr.expr.name == g.comptime.comptime_for_field_var {
-					field, _ := g.type_resolver.get_comptime_selector_var_type(node.expr)
-					name = g.styp(g.unwrap_generic(field.typ.clear_flags(.shared_f, .result)))
-					expr_type = field.typ
-				}
+		if node.expr.field_expr is ast.SelectorExpr && node.expr.field_expr.expr is ast.Ident {
+			if node.expr.field_expr.expr.name == g.comptime.comptime_for_field_var {
+				field, _ := g.type_resolver.get_comptime_selector_var_type(node.expr)
+				name = g.styp(g.unwrap_generic(field.typ.clear_flags(.shared_f, .result)))
+				expr_type = field.typ
 			}
 		}
 	} else if node.expr is ast.Ident && node.expr.ct_expr {
diff --git a/vlib/v/gen/c/fn.v b/vlib/v/gen/c/fn.v
@@ -1227,12 +1227,9 @@ fn (mut g Gen) gen_array_method_call(node ast.CallExpr, left_type ast.Type, left
 			array_depth := g.get_array_depth(array_info.elem_type)
 			to_depth := if array_depth >= 0 { '_to_depth' } else { '' }
 			mut is_range_slice := false
-			if node.left is ast.IndexExpr {
-				if node.left.index is ast.RangeExpr {
-					if node.name == 'clone' {
-						is_range_slice = true
-					}
-				}
+			if node.left is ast.IndexExpr && node.left.index is ast.RangeExpr
+				&& node.name == 'clone' {
+				is_range_slice = true
 			}
 			to_static := if is_range_slice { '_static' } else { '' }
 			g.write('array_${node.name}${to_static}${to_depth}(')
@@ -2072,23 +2069,21 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 							typ = m.return_type
 						}
 					}
-				} else if expr is ast.Ident {
-					if expr.obj is ast.Var {
-						typ = expr.obj.typ
-						if expr.obj.smartcasts.len > 0 {
-							typ = g.unwrap_generic(expr.obj.smartcasts.last())
-							cast_sym := g.table.sym(typ)
-							if cast_sym.info is ast.Aggregate {
-								typ = cast_sym.info.types[g.aggregate_type_idx]
-							} else if expr.obj.ct_type_var == .smartcast {
-								typ = g.unwrap_generic(g.type_resolver.get_type(expr))
-							}
-						}
-						// handling println( var or { ... })
-						if typ.has_flag(.option) && expr.or_expr.kind != .absent {
-							typ = typ.clear_flag(.option)
+				} else if expr is ast.Ident && expr.obj is ast.Var {
+					typ = expr.obj.typ
+					if expr.obj.smartcasts.len > 0 {
+						typ = g.unwrap_generic(expr.obj.smartcasts.last())
+						cast_sym := g.table.sym(typ)
+						if cast_sym.info is ast.Aggregate {
+							typ = cast_sym.info.types[g.aggregate_type_idx]
+						} else if expr.obj.ct_type_var == .smartcast {
+							typ = g.unwrap_generic(g.type_resolver.get_type(expr))
 						}
 					}
+					// handling println( var or { ... })
+					if typ.has_flag(.option) && expr.or_expr.kind != .absent {
+						typ = typ.clear_flag(.option)
+					}
 				}
 				g.gen_expr_to_string(expr, typ)
 				g.write(')')
@@ -2744,11 +2739,9 @@ fn (mut g Gen) ref_or_deref_arg(arg ast.CallArg, expected_type ast.Type, lang as
 		if (arg_sym.info is ast.Alias || exp_sym.info is ast.Alias) && expected_type != arg_typ {
 			g.expr_opt_with_alias(arg.expr, arg_typ, expected_type)
 		} else {
-			if arg.expr is ast.Ident {
-				if arg.expr.obj is ast.Var {
-					if arg.expr.obj.smartcasts.len > 0 {
-						arg_typ = arg.expr.obj.smartcasts.last()
-					}
+			if arg.expr is ast.Ident && arg.expr.obj is ast.Var {
+				if arg.expr.obj.smartcasts.len > 0 {
+					arg_typ = arg.expr.obj.smartcasts.last()
 				}
 			}
 			g.expr_with_opt(arg.expr, arg_typ, expected_type)
diff --git a/vlib/v/gen/c/for.v b/vlib/v/gen/c/for.v
@@ -80,16 +80,14 @@ fn (mut g Gen) for_c_stmt(node ast.ForCStmt) {
 		g.write('; ')
 		if node.has_inc {
 			mut processed := false
-			if node.inc is ast.ExprStmt {
-				if node.inc.expr is ast.ConcatExpr {
-					for inc_expr_idx, inc_expr in node.inc.expr.vals {
-						g.expr(inc_expr)
-						if inc_expr_idx < node.inc.expr.vals.len - 1 {
-							g.write(', ')
-						}
+			if node.inc is ast.ExprStmt && node.inc.expr is ast.ConcatExpr {
+				for inc_expr_idx, inc_expr in node.inc.expr.vals {
+					g.expr(inc_expr)
+					if inc_expr_idx < node.inc.expr.vals.len - 1 {
+						g.write(', ')
 					}
-					processed = true
 				}
+				processed = true
 			}
 			if !processed {
 				g.stmt(node.inc)
diff --git a/vlib/v/type_resolver/comptime_resolver.v b/vlib/v/type_resolver/comptime_resolver.v
@@ -132,10 +132,8 @@ pub fn (mut t TypeResolver) typeof_field_type(typ ast.Type, field_name string) a
 // 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 {
-	if node is ast.Ident {
-		if node.obj is ast.Var {
-			return node.obj.ct_type_var
-		}
+	if node is ast.Ident && node.obj is ast.Var {
+		return node.obj.ct_type_var
 	} else if node is ast.IndexExpr {
 		return t.get_ct_type_var(node.left)
 	} else if node is ast.InfixExpr {

Original file line number	Diff line number	Diff line change
`@@ -2594,10 +2594,8 @@ pub fn (mut lx IndexExpr) recursive_arraymap_set_is_setter() {`
`2594`	`2594`	`lx.is_setter = true`
`2595`	`2595`	`if mut lx.left is IndexExpr {`
`2596`	`2596`	`lx.left.recursive_arraymap_set_is_setter()`
`2597`		`- } else if mut lx.left is SelectorExpr {`
`2598`		`- if mut lx.left.expr is IndexExpr {`
`2599`		`- lx.left.expr.recursive_arraymap_set_is_setter()`
`2600`		`- }`
	`2597`	`+ } else if mut lx.left is SelectorExpr && lx.left.expr is IndexExpr {`
	`2598`	`+ lx.left.expr.recursive_arraymap_set_is_setter()`
`2601`	`2599`	`}`
`2602`	`2600`	`}`
`2603`	`2601`
Original file line number	Diff line number	Diff line change
`@@ -103,10 +103,8 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {`
`103`	`103`	c.error('cannot assign a `none` value to a variable', right.pos)
`104`	`104`	`}`
`105`	`105`	// Handle `left_name := unsafe { none }`
`106`		`- if mut right is ast.UnsafeExpr {`
`107`		`- if mut right.expr is ast.None {`
`108`		- c.error('cannot use `none` in `unsafe` blocks', right.expr.pos)
`109`		`- }`
	`106`	`+ if mut right is ast.UnsafeExpr && right.expr is ast.None {`
	`107`	+ c.error('cannot use `none` in `unsafe` blocks', right.expr.pos)
`110`	`108`	`}`
`111`	`109`	`if mut right is ast.AnonFn {`
`112`	`110`	`if right.decl.generic_names.len > 0 {`
`@@ -159,11 +157,9 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {`
`159`	`157`	`c.error('cannot dereference a function call on the left side of an assignment, use a temporary variable',`
`160`	`158`	`left.pos)`
`161`	`159`	`}`
`162`		`- } else if mut left is ast.IndexExpr {`
`163`		`- if left.index is ast.RangeExpr {`
`164`		`- c.error('cannot reassign using range expression on the left side of an assignment',`
`165`		`- left.pos)`
`166`		`- }`
	`160`	`+ } else if mut left is ast.IndexExpr && left.index is ast.RangeExpr {`
	`161`	`+ c.error('cannot reassign using range expression on the left side of an assignment',`
	`162`	`+ left.pos)`
`167`	`163`	`} else if mut left is ast.Ident && node.op == .decl_assign {`
`168`	`164`	`if left.name in c.global_names {`
`169`	`165`	c.note('the global variable named `${left.name}` already exists', left.pos)
`@@ -199,10 +195,8 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {`
`199`	`195`	`}`
`200`	`196`	`if node.right_types.len < node.left.len { // first type or multi return types added above`
`201`	`197`	`old_inside_ref_lit := c.inside_ref_lit`
`202`		`- if mut left is ast.Ident {`
`203`		`- if mut left.info is ast.IdentVar {`
`204`		`- c.inside_ref_lit = c.inside_ref_lit \|\| left.info.share == .shared_t`
`205`		`- }`
	`198`	`+ if mut left is ast.Ident && left.info is ast.IdentVar {`
	`199`	`+ c.inside_ref_lit = c.inside_ref_lit \|\| left.info.share == .shared_t`
`206`	`200`	`}`
`207`	`201`	`c.inside_decl_rhs = is_decl`
`208`	`202`	`mut expr := node.right[i]`
@@ -666,11 +660,9 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
`666`	`660`	`}`
`667`	`661`	`}`
`668`	`662`	`}`
`669`		`- if mut left is ast.Ident {`
`670`		`- if mut left.info is ast.IdentVar {`
`671`		`- if left.info.is_static && right_sym.kind == .map {`
`672`		`- c.error('maps cannot be static', left.pos)`
`673`		`- }`
	`663`	`+ if mut left is ast.Ident && left.info is ast.IdentVar {`
	`664`	`+ if left.info.is_static && right_sym.kind == .map {`
	`665`	`+ c.error('maps cannot be static', left.pos)`
`674`	`666`	`}`
`675`	`667`	`}`
`676`	`668`	`// Single side check`
Original file line number	Diff line number	Diff line change
`@@ -799,10 +799,8 @@ fn (mut c Checker) check_append(mut node ast.InfixExpr, left_type ast.Type, righ`
`799`	`799`	`right := node.right`
`800`	`800`	`if right is ast.PrefixExpr && right.op == .amp {`
`801`	`801`	`mut expr2 := right.right`
`802`		`- if mut expr2 is ast.Ident {`
`803`		`- if !node.left.is_blank_ident() && expr2.obj is ast.ConstField {`
`804`		- c.error('cannot have mutable reference to const `${expr2.name}`', expr2.pos)
`805`		`- }`
	`802`	`+ if mut expr2 is ast.Ident && !node.left.is_blank_ident() && expr2.obj is ast.ConstField {`
	`803`	+ c.error('cannot have mutable reference to const `${expr2.name}`', expr2.pos)
`806`	`804`	`}`
`807`	`805`	`}`
`808`	`806`	`if left_value_sym.kind == .interface {`
Original file line number	Diff line number	Diff line change
`@@ -1520,10 +1520,8 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.`
`1520`	`1520`	`}`
`1521`	`1521`	`node.args[i].typ = arg_typ`
`1522`	`1522`	`if c.comptime.comptime_for_field_var != '' {`
`1523`		`- if mut call_arg.expr is ast.Ident {`
`1524`		`- if mut call_arg.expr.obj is ast.Var {`
`1525`		`- node.args[i].typ = call_arg.expr.obj.typ`
`1526`		`- }`
	`1523`	`+ if mut call_arg.expr is ast.Ident && call_arg.expr.obj is ast.Var {`
	`1524`	`+ node.args[i].typ = call_arg.expr.obj.typ`
`1527`	`1525`	`}`
`1528`	`1526`	`}`
`1529`	`1527`	`arg_typ_sym := c.table.sym(arg_typ)`
Original file line number	Diff line number	Diff line change
`@@ -318,13 +318,11 @@ fn (mut c Checker) for_stmt(mut node ast.ForStmt) {`
`318`	`318`	`c.error('non-bool used as for condition', node.pos)`
`319`	`319`	`}`
`320`	`320`	`}`
`321`		`- if mut node.cond is ast.InfixExpr {`
`322`		`- if node.cond.op == .key_is {`
`323`		`- if node.cond.right is ast.TypeNode && node.cond.left in [ast.Ident, ast.SelectorExpr] {`
`324`		`- if c.table.type_kind(node.cond.left_type) in [.sum_type, .interface] {`
`325`		`- c.smartcast(mut node.cond.left, node.cond.left_type, node.cond.right_type, mut`
`326`		`- node.scope, false, false)`
`327`		`- }`
	`321`	`+ if mut node.cond is ast.InfixExpr && node.cond.op == .key_is {`
	`322`	`+ if node.cond.right is ast.TypeNode && node.cond.left in [ast.Ident, ast.SelectorExpr] {`
	`323`	`+ if c.table.type_kind(node.cond.left_type) in [.sum_type, .interface] {`
	`324`	`+ c.smartcast(mut node.cond.left, node.cond.left_type, node.cond.right_type, mut`
	`325`	`+ node.scope, false, false)`
`328`	`326`	`}`
`329`	`327`	`}`
`330`	`328`	`}`
Original file line number	Diff line number	Diff line change
`@@ -308,10 +308,8 @@ fn (mut c Checker) get_comptime_number_value(mut expr ast.Expr) ?i64 {`
`308`	`308`	`if mut expr is ast.IntegerLiteral {`
`309`	`309`	`return expr.val.i64()`
`310`	`310`	`}`
`311`		`- if mut expr is ast.CastExpr {`
`312`		`- if mut expr.expr is ast.IntegerLiteral {`
`313`		`- return expr.expr.val.i64()`
`314`		`- }`
	`311`	`+ if mut expr is ast.CastExpr && expr.expr is ast.IntegerLiteral {`
	`312`	`+ return expr.expr.val.i64()`
`315`	`313`	`}`
`316`	`314`	`if mut expr is ast.Ident {`
`317`	`315`	`if mut obj := c.table.global_scope.find_const(expr.full_name()) {`
Original file line number	Diff line number	Diff line change
`@@ -34,13 +34,11 @@ fn (mut g Gen) dump_expr(node ast.DumpExpr) {`
`34`	`34`	`}`
`35`	`35`	`// var.$(field.name)`
`36`	`36`	`if node.expr is ast.ComptimeSelector && node.expr.is_name {`
`37`		`- if node.expr.field_expr is ast.SelectorExpr {`
`38`		`- if node.expr.field_expr.expr is ast.Ident {`
`39`		`- if node.expr.field_expr.expr.name == g.comptime.comptime_for_field_var {`
`40`		`- field, _ := g.type_resolver.get_comptime_selector_var_type(node.expr)`
`41`		`- name = g.styp(g.unwrap_generic(field.typ.clear_flags(.shared_f, .result)))`
`42`		`- expr_type = field.typ`
`43`		`- }`
	`37`	`+ if node.expr.field_expr is ast.SelectorExpr && node.expr.field_expr.expr is ast.Ident {`
	`38`	`+ if node.expr.field_expr.expr.name == g.comptime.comptime_for_field_var {`
	`39`	`+ field, _ := g.type_resolver.get_comptime_selector_var_type(node.expr)`
	`40`	`+ name = g.styp(g.unwrap_generic(field.typ.clear_flags(.shared_f, .result)))`
	`41`	`+ expr_type = field.typ`
`44`	`42`	`}`
`45`	`43`	`}`
`46`	`44`	`} else if node.expr is ast.Ident && node.expr.ct_expr {`