checker: change 'fail_if_immutable(expr_ ast.Expr)' to 'fail_if_immutable(mut expr ast.Expr)' (#18811)

yuyi98 · web-flow · commit 17b576227fff · 2023-07-07T23:27:52.000+03:00
diff --git a/vlib/v/checker/assign.v b/vlib/v/checker/assign.v
@@ -227,7 +227,7 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {
 			}
 		} else {
 			// Make sure the variable is mutable
-			c.fail_if_immutable(left)
+			c.fail_if_immutable(mut left)
 
 			if !is_blank_ident && !left_type.has_flag(.option) && right_type.has_flag(.option) {
 				c.error('cannot assign an Option value to a non-option variable', right.pos())
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -661,21 +661,21 @@ fn (mut c Checker) expand_iface_embeds(idecl &ast.InterfaceDecl, level int, ifac
 
 // returns name and position of variable that needs write lock
 // also sets `is_changed` to true (TODO update the name to reflect this?)
-fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
+fn (mut c Checker) fail_if_immutable(mut expr ast.Expr) (string, token.Pos) {
 	mut to_lock := '' // name of variable that needs lock
 	mut pos := token.Pos{} // and its position
 	mut explicit_lock_needed := false
-	mut expr := unsafe { expr_ }
 	match mut expr {
 		ast.CastExpr {
 			// TODO
 			return '', expr.pos
 		}
 		ast.ComptimeSelector {
+			mut expr_left := expr.left
 			if mut expr.left is ast.Ident {
 				if mut expr.left.obj is ast.Var {
 					if expr.left.obj.ct_type_var != .generic_param {
-						c.fail_if_immutable(expr.left)
+						c.fail_if_immutable(mut expr_left)
 					}
 				}
 			}
@@ -735,21 +735,21 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 				c.error('you have to create a handle and `lock` it to modify `shared` ${kind} element',
 					expr.left.pos().extend(expr.pos))
 			}
-			to_lock, pos = c.fail_if_immutable(expr.left)
+			to_lock, pos = c.fail_if_immutable(mut expr.left)
 		}
 		ast.ParExpr {
-			to_lock, pos = c.fail_if_immutable(expr.expr)
+			to_lock, pos = c.fail_if_immutable(mut expr.expr)
 		}
 		ast.PrefixExpr {
 			if expr.op == .mul && expr.right is ast.Ident {
 				// Do not fail if dereference is immutable:
 				// `*x = foo()` doesn't modify `x`
 			} else {
-				to_lock, pos = c.fail_if_immutable(expr.right)
+				to_lock, pos = c.fail_if_immutable(mut expr.right)
 			}
 		}
 		ast.PostfixExpr {
-			to_lock, pos = c.fail_if_immutable(expr.expr)
+			to_lock, pos = c.fail_if_immutable(mut expr.expr)
 		}
 		ast.SelectorExpr {
 			if expr.expr_type == 0 {
@@ -792,7 +792,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 							c.error('field `${expr.field_name}` of struct `${type_str}` is immutable',
 								expr.pos)
 						}
-						to_lock, pos = c.fail_if_immutable(expr.expr)
+						to_lock, pos = c.fail_if_immutable(mut expr.expr)
 					}
 					if to_lock != '' {
 						// No automatic lock for struct access
@@ -812,7 +812,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 							expr.pos)
 						return '', expr.pos
 					}
-					c.fail_if_immutable(expr.expr)
+					c.fail_if_immutable(mut expr.expr)
 				}
 				.sum_type {
 					sumtype_info := typ_sym.info as ast.SumType
@@ -827,7 +827,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 							expr.pos)
 						return '', expr.pos
 					}
-					c.fail_if_immutable(expr.expr)
+					c.fail_if_immutable(mut expr.expr)
 				}
 				.array, .string {
 					// should only happen in `builtin` and unsafe blocks
@@ -838,7 +838,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 					}
 				}
 				.aggregate, .placeholder {
-					c.fail_if_immutable(expr.expr)
+					c.fail_if_immutable(mut expr.expr)
 				}
 				else {
 					c.error('unexpected symbol `${typ_sym.kind}`', expr.pos)
@@ -849,7 +849,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {
 		ast.CallExpr {
 			// TODO: should only work for builtin method
 			if expr.name == 'slice' {
-				to_lock, pos = c.fail_if_immutable(expr.left)
+				to_lock, pos = c.fail_if_immutable(mut expr.left)
 				if to_lock != '' {
 					// No automatic lock for array slicing (yet(?))
 					explicit_lock_needed = true
@@ -2153,7 +2153,7 @@ fn (mut c Checker) asm_ios(mut ios []ast.AsmIO, mut scope ast.Scope, output bool
 	for mut io in ios {
 		typ := c.expr(mut io.expr)
 		if output {
-			c.fail_if_immutable(io.expr)
+			c.fail_if_immutable(mut io.expr)
 		}
 		if io.alias != '' {
 			aliases << io.alias
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -1101,7 +1101,7 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 				call_arg.pos)
 		}
 		if call_arg.is_mut {
-			to_lock, pos := c.fail_if_immutable(call_arg.expr)
+			to_lock, pos := c.fail_if_immutable(mut call_arg.expr)
 			if !call_arg.expr.is_lvalue() {
 				if call_arg.expr is ast.StructInit {
 					c.error('cannot pass a struct initialization as `mut`, you may want to use a variable `mut var := ${call_arg.expr}`',
@@ -1744,7 +1744,7 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 							arg.pos)
 					}
 					if arg.is_mut {
-						to_lock, pos := c.fail_if_immutable(arg.expr)
+						to_lock, pos := c.fail_if_immutable(mut arg.expr)
 						if !param.is_mut {
 							tok := arg.share.str()
 							c.error('`${node.name}` parameter ${i + 1} is not `${tok}`, `${tok}` is not needed`',
@@ -1846,7 +1846,7 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 			node.pos)
 	}
 	if method.params[0].is_mut {
-		to_lock, pos := c.fail_if_immutable(node.left)
+		to_lock, pos := c.fail_if_immutable(mut node.left)
 		if !node.left.is_lvalue() {
 			c.error('cannot pass expression as `mut`', node.left.pos())
 		}
@@ -1968,7 +1968,7 @@ fn (mut c Checker) method_call(mut node ast.CallExpr) ast.Type {
 				arg.pos)
 		}
 		if arg.is_mut {
-			to_lock, pos := c.fail_if_immutable(arg.expr)
+			to_lock, pos := c.fail_if_immutable(mut arg.expr)
 			if !param_is_mut {
 				tok := arg.share.str()
 				c.error('`${node.name}` parameter `${param.name}` is not `${tok}`, `${tok}` is not needed`',
@@ -2426,7 +2426,7 @@ fn (mut c Checker) map_builtin_method_call(mut node ast.CallExpr, left_type ast.
 				c.error('`.${method_name}()` does not have any arguments', node.args[0].pos)
 			}
 			if method_name[0] == `m` {
-				c.fail_if_immutable(node.left)
+				c.fail_if_immutable(mut node.left)
 			}
 			if node.left.is_auto_deref_var() || ret_type.has_flag(.shared_f) {
 				ret_type = left_type.deref()
@@ -2454,7 +2454,7 @@ fn (mut c Checker) map_builtin_method_call(mut node ast.CallExpr, left_type ast.
 			}
 		}
 		'delete' {
-			c.fail_if_immutable(node.left)
+			c.fail_if_immutable(mut node.left)
 			if node.args.len != 1 {
 				c.error('expected 1 argument, but got ${node.args.len}', node.pos)
 			}
@@ -2491,7 +2491,7 @@ fn (mut c Checker) array_builtin_method_call(mut node ast.CallExpr, left_type as
 			c.error('the `sort()` method can be called only on mutable receivers, but `${node.left}` is a call expression',
 				node.pos)
 		}
-		c.fail_if_immutable(node.left)
+		c.fail_if_immutable(mut node.left)
 		// position of `a` and `b` doesn't matter, they're the same
 		scope_register_a_b(mut node.scope, node.pos, elem_typ)
 
@@ -2635,13 +2635,13 @@ fn (mut c Checker) array_builtin_method_call(mut node ast.CallExpr, left_type as
 		}
 		node.return_type = array_info.elem_type
 		if method_name == 'pop' {
-			c.fail_if_immutable(node.left)
+			c.fail_if_immutable(mut node.left)
 			node.receiver_type = left_type.ref()
 		} else {
 			node.receiver_type = left_type
 		}
 	} else if method_name == 'delete' {
-		c.fail_if_immutable(node.left)
+		c.fail_if_immutable(mut node.left)
 		unwrapped_left_sym := c.table.sym(c.unwrap_generic(left_type))
 		if method := c.table.find_method(unwrapped_left_sym, method_name) {
 			node.receiver_type = method.receiver_type
diff --git a/vlib/v/checker/if.v b/vlib/v/checker/if.v
@@ -509,7 +509,7 @@ fn (mut c Checker) smartcast_if_conds(mut node ast.Expr, mut scope ast.Scope) {
 					if is_variable {
 						if (node.left is ast.Ident && node.left.is_mut)
 							|| (node.left is ast.SelectorExpr && node.left.is_mut) {
-							c.fail_if_immutable(node.left)
+							c.fail_if_immutable(mut node.left)
 						}
 						// TODO: Add check for sum types in a way that it doesn't break a lot of compiler code
 						if mut node.left is ast.Ident
diff --git a/vlib/v/checker/infix.v b/vlib/v/checker/infix.v
@@ -505,7 +505,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 				}
 				// `array << elm`
 				c.check_expr_opt_call(node.right, right_type)
-				node.auto_locked, _ = c.fail_if_immutable(node.left)
+				node.auto_locked, _ = c.fail_if_immutable(mut node.left)
 				left_value_type := c.table.value_type(c.unwrap_generic(left_type))
 				left_value_sym := c.table.sym(c.unwrap_generic(left_value_type))
 				if left_value_sym.kind == .interface_ {
@@ -661,7 +661,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 				}
 				if chan_info.is_mut {
 					// TODO: The error message of the following could be more specific...
-					c.fail_if_immutable(node.right)
+					c.fail_if_immutable(mut node.right)
 				}
 				if elem_type.is_ptr() && !right_type.is_ptr() {
 					c.error('cannot push non-reference `${right_sym.name}` on `${left_sym.name}`',
diff --git a/vlib/v/checker/match.v b/vlib/v/checker/match.v
@@ -24,7 +24,7 @@ fn (mut c Checker) match_expr(mut node ast.MatchExpr) ast.Type {
 	node.cond_type = ast.mktyp(cond_type)
 	if (node.cond is ast.Ident && node.cond.is_mut)
 		|| (node.cond is ast.SelectorExpr && node.cond.is_mut) {
-		c.fail_if_immutable(node.cond)
+		c.fail_if_immutable(mut node.cond)
 	}
 	c.ensure_type_exists(node.cond_type, node.pos) or { return ast.void_type }
 	c.check_expr_opt_call(node.cond, cond_type)
diff --git a/vlib/v/checker/postfix.v b/vlib/v/checker/postfix.v
@@ -37,7 +37,7 @@ fn (mut c Checker) postfix_expr(mut node ast.PostfixExpr) ast.Type {
 		c.error('invalid operation: ${node.op.str()} (non-numeric type `${typ_str}`)',
 			node.pos)
 	} else {
-		node.auto_locked, _ = c.fail_if_immutable(node.expr)
+		node.auto_locked, _ = c.fail_if_immutable(mut node.expr)
 	}
 	node.typ = typ
 	return typ

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) {`
`227`	`227`	`}`
`228`	`228`	`} else {`
`229`	`229`	`// Make sure the variable is mutable`
`230`		`- c.fail_if_immutable(left)`
	`230`	`+ c.fail_if_immutable(mut left)`
`231`	`231`
`232`	`232`	`if !is_blank_ident && !left_type.has_flag(.option) && right_type.has_flag(.option) {`
`233`	`233`	`c.error('cannot assign an Option value to a non-option variable', right.pos())`
Original file line number	Diff line number	Diff line change
`@@ -661,21 +661,21 @@ fn (mut c Checker) expand_iface_embeds(idecl &ast.InterfaceDecl, level int, ifac`
`661`	`661`
`662`	`662`	`// returns name and position of variable that needs write lock`
`663`	`663`	// also sets `is_changed` to true (TODO update the name to reflect this?)
`664`		`-fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
	`664`	`+fn (mut c Checker) fail_if_immutable(mut expr ast.Expr) (string, token.Pos) {`
`665`	`665`	`mut to_lock := '' // name of variable that needs lock`
`666`	`666`	`mut pos := token.Pos{} // and its position`
`667`	`667`	`mut explicit_lock_needed := false`
`668`		`- mut expr := unsafe { expr_ }`
`669`	`668`	`match mut expr {`
`670`	`669`	`ast.CastExpr {`
`671`	`670`	`// TODO`
`672`	`671`	`return '', expr.pos`
`673`	`672`	`}`
`674`	`673`	`ast.ComptimeSelector {`
	`674`	`+ mut expr_left := expr.left`
`675`	`675`	`if mut expr.left is ast.Ident {`
`676`	`676`	`if mut expr.left.obj is ast.Var {`
`677`	`677`	`if expr.left.obj.ct_type_var != .generic_param {`
`678`		`- c.fail_if_immutable(expr.left)`
	`678`	`+ c.fail_if_immutable(mut expr_left)`
`679`	`679`	`}`
`680`	`680`	`}`
`681`	`681`	`}`
`@@ -735,21 +735,21 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`735`	`735`	c.error('you have to create a handle and `lock` it to modify `shared` ${kind} element',
`736`	`736`	`expr.left.pos().extend(expr.pos))`
`737`	`737`	`}`
`738`		`- to_lock, pos = c.fail_if_immutable(expr.left)`
	`738`	`+ to_lock, pos = c.fail_if_immutable(mut expr.left)`
`739`	`739`	`}`
`740`	`740`	`ast.ParExpr {`
`741`		`- to_lock, pos = c.fail_if_immutable(expr.expr)`
	`741`	`+ to_lock, pos = c.fail_if_immutable(mut expr.expr)`
`742`	`742`	`}`
`743`	`743`	`ast.PrefixExpr {`
`744`	`744`	`if expr.op == .mul && expr.right is ast.Ident {`
`745`	`745`	`// Do not fail if dereference is immutable:`
`746`	`746`	// `*x = foo()` doesn't modify `x`
`747`	`747`	`} else {`
`748`		`- to_lock, pos = c.fail_if_immutable(expr.right)`
	`748`	`+ to_lock, pos = c.fail_if_immutable(mut expr.right)`
`749`	`749`	`}`
`750`	`750`	`}`
`751`	`751`	`ast.PostfixExpr {`
`752`		`- to_lock, pos = c.fail_if_immutable(expr.expr)`
	`752`	`+ to_lock, pos = c.fail_if_immutable(mut expr.expr)`
`753`	`753`	`}`
`754`	`754`	`ast.SelectorExpr {`
`755`	`755`	`if expr.expr_type == 0 {`
`@@ -792,7 +792,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`792`	`792`	c.error('field `${expr.field_name}` of struct `${type_str}` is immutable',
`793`	`793`	`expr.pos)`
`794`	`794`	`}`
`795`		`- to_lock, pos = c.fail_if_immutable(expr.expr)`
	`795`	`+ to_lock, pos = c.fail_if_immutable(mut expr.expr)`
`796`	`796`	`}`
`797`	`797`	`if to_lock != '' {`
`798`	`798`	`// No automatic lock for struct access`
`@@ -812,7 +812,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`812`	`812`	`expr.pos)`
`813`	`813`	`return '', expr.pos`
`814`	`814`	`}`
`815`		`- c.fail_if_immutable(expr.expr)`
	`815`	`+ c.fail_if_immutable(mut expr.expr)`
`816`	`816`	`}`
`817`	`817`	`.sum_type {`
`818`	`818`	`sumtype_info := typ_sym.info as ast.SumType`
`@@ -827,7 +827,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`827`	`827`	`expr.pos)`
`828`	`828`	`return '', expr.pos`
`829`	`829`	`}`
`830`		`- c.fail_if_immutable(expr.expr)`
	`830`	`+ c.fail_if_immutable(mut expr.expr)`
`831`	`831`	`}`
`832`	`832`	`.array, .string {`
`833`	`833`	// should only happen in `builtin` and unsafe blocks
`@@ -838,7 +838,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`838`	`838`	`}`
`839`	`839`	`}`
`840`	`840`	`.aggregate, .placeholder {`
`841`		`- c.fail_if_immutable(expr.expr)`
	`841`	`+ c.fail_if_immutable(mut expr.expr)`
`842`	`842`	`}`
`843`	`843`	`else {`
`844`	`844`	c.error('unexpected symbol `${typ_sym.kind}`', expr.pos)
`@@ -849,7 +849,7 @@ fn (mut c Checker) fail_if_immutable(expr_ ast.Expr) (string, token.Pos) {`
`849`	`849`	`ast.CallExpr {`
`850`	`850`	`// TODO: should only work for builtin method`
`851`	`851`	`if expr.name == 'slice' {`
`852`		`- to_lock, pos = c.fail_if_immutable(expr.left)`
	`852`	`+ to_lock, pos = c.fail_if_immutable(mut expr.left)`
`853`	`853`	`if to_lock != '' {`
`854`	`854`	`// No automatic lock for array slicing (yet(?))`
`855`	`855`	`explicit_lock_needed = true`
`@@ -2153,7 +2153,7 @@ fn (mut c Checker) asm_ios(mut ios []ast.AsmIO, mut scope ast.Scope, output bool`
`2153`	`2153`	`for mut io in ios {`
`2154`	`2154`	`typ := c.expr(mut io.expr)`
`2155`	`2155`	`if output {`
`2156`		`- c.fail_if_immutable(io.expr)`
	`2156`	`+ c.fail_if_immutable(mut io.expr)`
`2157`	`2157`	`}`
`2158`	`2158`	`if io.alias != '' {`
`2159`	`2159`	`aliases << io.alias`
Original file line number	Diff line number	Diff line change
`@@ -509,7 +509,7 @@ fn (mut c Checker) smartcast_if_conds(mut node ast.Expr, mut scope ast.Scope) {`
`509`	`509`	`if is_variable {`
`510`	`510`	`if (node.left is ast.Ident && node.left.is_mut)`
`511`	`511`	`\|\| (node.left is ast.SelectorExpr && node.left.is_mut) {`
`512`		`- c.fail_if_immutable(node.left)`
	`512`	`+ c.fail_if_immutable(mut node.left)`
`513`	`513`	`}`
`514`	`514`	`// TODO: Add check for sum types in a way that it doesn't break a lot of compiler code`
`515`	`515`	`if mut node.left is ast.Ident`
Original file line number	Diff line number	Diff line change
`@@ -505,7 +505,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {`
`505`	`505`	`}`
`506`	`506`	// `array << elm`
`507`	`507`	`c.check_expr_opt_call(node.right, right_type)`
`508`		`- node.auto_locked, _ = c.fail_if_immutable(node.left)`
	`508`	`+ node.auto_locked, _ = c.fail_if_immutable(mut node.left)`
`509`	`509`	`left_value_type := c.table.value_type(c.unwrap_generic(left_type))`
`510`	`510`	`left_value_sym := c.table.sym(c.unwrap_generic(left_value_type))`
`511`	`511`	`if left_value_sym.kind == .interface_ {`
`@@ -661,7 +661,7 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {`
`661`	`661`	`}`
`662`	`662`	`if chan_info.is_mut {`
`663`	`663`	`// TODO: The error message of the following could be more specific...`
`664`		`- c.fail_if_immutable(node.right)`
	`664`	`+ c.fail_if_immutable(mut node.right)`
`665`	`665`	`}`
`666`	`666`	`if elem_type.is_ptr() && !right_type.is_ptr() {`
`667`	`667`	c.error('cannot push non-reference `${right_sym.name}` on `${left_sym.name}`',
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ fn (mut c Checker) match_expr(mut node ast.MatchExpr) ast.Type {`
`24`	`24`	`node.cond_type = ast.mktyp(cond_type)`
`25`	`25`	`if (node.cond is ast.Ident && node.cond.is_mut)`
`26`	`26`	`\|\| (node.cond is ast.SelectorExpr && node.cond.is_mut) {`
`27`		`- c.fail_if_immutable(node.cond)`
	`27`	`+ c.fail_if_immutable(mut node.cond)`
`28`	`28`	`}`
`29`	`29`	`c.ensure_type_exists(node.cond_type, node.pos) or { return ast.void_type }`
`30`	`30`	`c.check_expr_opt_call(node.cond, cond_type)`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ fn (mut c Checker) postfix_expr(mut node ast.PostfixExpr) ast.Type {`
`37`	`37`	c.error('invalid operation: ${node.op.str()} (non-numeric type `${typ_str}`)',
`38`	`38`	`node.pos)`
`39`	`39`	`} else {`
`40`		`- node.auto_locked, _ = c.fail_if_immutable(node.expr)`
	`40`	`+ node.auto_locked, _ = c.fail_if_immutable(mut node.expr)`
`41`	`41`	`}`
`42`	`42`	`node.typ = typ`
`43`	`43`	`return typ`