parser,checker,cgen: remove unused err declaration or or { } blocks (#25034)

Author: felipensp

cmd/tools/vast/vast.v

@@ -1646,6 +1646,7 @@ fn (t Tree) or_expr(node ast.OrExpr) &Node {
 	obj.add_terse('stmts', t.array_node_stmt(node.stmts))
 	obj.add_terse('kind', t.enum_node(node.kind))
 	obj.add('pos', t.pos(node.pos))
+	obj.add('scope', t.number_node(int(node.scope)))
 	return obj
 }
 

vlib/builtin/sorted_map.v

@@ -14,6 +14,10 @@ module builtin
 // The number for `degree` has been picked through vigor-
 // ous benchmarking but can be changed to any number > 1.
 // `degree` determines the maximum length of each node.
+// TODO: the @[markused] tag here is needed as a workaround for
+// compilation with `-cc clang -usecache`; added in https://github.com/vlang/v/pull/25034
+
+@[markused]
 const degree = 6
 const mid_index = degree - 1
 const max_len = 2 * degree - 1

vlib/v/ast/ast.v

@@ -935,6 +935,7 @@ pub mut:
 	is_tmp       bool // for tmp for loop vars, so that autofree can skip them
 	is_auto_heap bool // value whose address goes out of scope
 	is_stack_obj bool // may be pointer to stack value (`mut` or `&` arg and not @[heap] struct)
+	is_special   bool // err, it, a, b vars (ignore not useds)
 }
 
 // used for smartcasting only
@@ -1912,10 +1913,12 @@ pub enum OrKind {
 // `or { ... }`
 pub struct OrExpr {
 pub:
-	kind OrKind
-	pos  token.Pos
+	kind  OrKind
+	pos   token.Pos
+	scope &Scope = unsafe { nil }
 pub mut:
-	stmts []Stmt
+	err_used bool
+	stmts    []Stmt
 }
 
 /*

vlib/v/checker/checker.v

@@ -113,6 +113,7 @@ mut:
 	type_level                       int // to avoid infinite recursion segfaults due to compiler bugs in ensure_type_exists
 	ensure_generic_type_level        int // to avoid infinite recursion segfaults in ensure_generic_type_specify_type_names
 	cur_orm_ts                       ast.TypeSymbol
+	cur_or_expr                      &ast.OrExpr = unsafe { nil }
 	cur_anon_fn                      &ast.AnonFn = unsafe { nil }
 	vmod_file_content                string     // needed for @VMOD_FILE, contents of the file, *NOT its path**
 	loop_labels                      []string   // filled, when inside labelled for loops: `a_label: for x in 0..10 {`
@@ -299,7 +300,7 @@ pub fn (mut c Checker) check_scope_vars(sc &ast.Scope) {
 		for _, obj in sc.objects {
 			match obj {
 				ast.Var {
-					if !obj.is_used && obj.name[0] != `_` {
+					if !obj.is_special && !obj.is_used && obj.name[0] != `_` {
 						if !c.pref.translated && !c.file.is_translated {
 							if obj.is_arg {
 								if c.pref.show_unused_params {
@@ -310,11 +311,11 @@ pub fn (mut c Checker) check_scope_vars(sc &ast.Scope) {
 							}
 						}
 					}
-					if obj.is_mut && !obj.is_changed && !c.is_builtin_mod && obj.name != 'it' {
-						// if obj.is_mut && !obj.is_changed && !c.is_builtin {  //TODO C error bad field not checked
-						// c.warn('`$obj.name` is declared as mutable, but it was never changed',
-						// obj.pos)
-					}
+					// if obj.is_mut && !obj.is_changed && !c.is_builtin_mod && obj.name != 'it' {
+					// if obj.is_mut && !obj.is_changed && !c.is_builtin {  //TODO C error bad field not checked
+					// c.warn('`$obj.name` is declared as mutable, but it was never changed',
+					// obj.pos)
+					// }
 				}
 				else {}
 			}
@@ -1338,7 +1339,10 @@ fn (mut c Checker) check_expr_option_or_result_call(expr ast.Expr, ret_type ast.
 						}
 					}
 				} else {
+					last_cur_or_expr := c.cur_or_expr
+					c.cur_or_expr = &expr.or_block
 					c.check_or_expr(expr.or_block, ret_type, expr_ret_type, expr)
+					c.cur_or_expr = last_cur_or_expr
 				}
 				return ret_type.clear_flag(.result)
 			} else {
@@ -1365,7 +1369,10 @@ fn (mut c Checker) check_expr_option_or_result_call(expr ast.Expr, ret_type ast.
 						}
 					} else {
 						if expr.or_block.kind != .absent {
+							last_cur_or_expr := c.cur_or_expr
+							c.cur_or_expr = &expr.or_block
 							c.check_or_expr(expr.or_block, ret_type, expr.typ, expr)
+							c.cur_or_expr = last_cur_or_expr
 						}
 					}
 					return ret_type.clear_flag(.result)
@@ -1389,8 +1396,11 @@ fn (mut c Checker) check_expr_option_or_result_call(expr ast.Expr, ret_type ast.
 				if return_none_or_error {
 					c.check_expr_option_or_result_call(expr.or_expr, c.table.cur_fn.return_type)
 				} else {
+					last_cur_or_expr := c.cur_or_expr
+					c.cur_or_expr = &expr.or_expr
 					c.check_or_expr(expr.or_expr, ret_type, ret_type.set_flag(.result),
 						expr)
+					c.cur_or_expr = last_cur_or_expr
 				}
 			} else if expr.left is ast.SelectorExpr && expr.left_type.has_option_or_result() {
 				with_modifier_kind := if expr.left_type.has_flag(.option) {
@@ -1464,6 +1474,10 @@ fn (mut c Checker) check_or_expr(node ast.OrExpr, ret_type ast.Type, expr_return
 		}
 		// allow `f() or {}`
 		return
+	} else if !node.err_used {
+		if err_var := node.scope.find_var('err') {
+			c.cur_or_expr.err_used = err_var.is_used
+		}
 	}
 	mut valid_stmts := node.stmts.filter(it !is ast.SemicolonStmt)
 	mut last_stmt := if valid_stmts.len > 0 { valid_stmts.last() } else { node.stmts.last() }
@@ -1809,7 +1823,10 @@ fn (mut c Checker) selector_expr(mut node ast.SelectorExpr) ast.Type {
 			unwrapped_typ := c.unwrap_generic(node.typ)
 			c.expected_or_type = unwrapped_typ.clear_option_and_result()
 			c.stmts_ending_with_expression(mut node.or_block.stmts, c.expected_or_type)
+			last_cur_or_expr := c.cur_or_expr
+			c.cur_or_expr = &node.or_block
 			c.check_or_expr(node.or_block, unwrapped_typ, c.expected_or_type, node)
+			c.cur_or_expr = last_cur_or_expr
 			c.expected_or_type = ast.void_type
 		}
 		return field.typ
@@ -4079,7 +4096,10 @@ fn (mut c Checker) ident(mut node ast.Ident) ast.Type {
 			unwrapped_typ := typ.clear_option_and_result()
 			c.expected_or_type = unwrapped_typ
 			c.stmts_ending_with_expression(mut node.or_expr.stmts, c.expected_or_type)
+			last_cur_or_expr := c.cur_or_expr
+			c.cur_or_expr = &node.or_expr
 			c.check_or_expr(node.or_expr, typ, c.expected_or_type, node)
+			c.cur_or_expr = last_cur_or_expr
 			return unwrapped_typ
 		}
 		return typ
@@ -4194,7 +4214,10 @@ fn (mut c Checker) ident(mut node ast.Ident) ast.Type {
 						unwrapped_typ := typ.clear_option_and_result()
 						c.expected_or_type = unwrapped_typ
 						c.stmts_ending_with_expression(mut node.or_expr.stmts, c.expected_or_type)
+						last_cur_or_expr := c.cur_or_expr
+						c.cur_or_expr = &node.or_expr
 						c.check_or_expr(node.or_expr, typ, c.expected_or_type, node)
+						c.cur_or_expr = last_cur_or_expr
 						return unwrapped_typ
 					}
 					return typ
@@ -4256,7 +4279,10 @@ fn (mut c Checker) ident(mut node ast.Ident) ast.Type {
 						unwrapped_typ := typ.clear_option_and_result()
 						c.expected_or_type = unwrapped_typ
 						c.stmts_ending_with_expression(mut node.or_expr.stmts, c.expected_or_type)
+						last_cur_or_expr := c.cur_or_expr
+						c.cur_or_expr = &node.or_expr
 						c.check_or_expr(node.or_expr, typ, c.expected_or_type, node)
+						c.cur_or_expr = last_cur_or_expr
 					}
 					return typ
 				}

vlib/v/checker/fn.v

@@ -783,7 +783,10 @@ fn (mut c Checker) call_expr(mut node ast.CallExpr) ast.Type {
 	if node.or_block.kind == .block {
 		old_inside_or_block_value := c.inside_or_block_value
 		c.inside_or_block_value = true
+		last_cur_or_expr := c.cur_or_expr
+		c.cur_or_expr = &node.or_block
 		c.check_or_expr(node.or_block, typ, c.expected_or_type, node)
+		c.cur_or_expr = last_cur_or_expr
 		c.inside_or_block_value = old_inside_or_block_value
 	}
 	c.expected_or_type = old_expected_or_type
@@ -3819,10 +3822,11 @@ fn scope_register_a_b(mut s ast.Scope, pos token.Pos, typ ast.Type) {
 
 fn scope_register_var_name(mut s ast.Scope, pos token.Pos, typ ast.Type, name string) {
 	s.register(ast.Var{
-		name:    name
-		pos:     pos
-		typ:     typ
-		is_used: true
+		name:       name
+		pos:        pos
+		typ:        typ
+		is_used:    false
+		is_special: true
 	})
 }
 

vlib/v/checker/orm.v

@@ -192,8 +192,10 @@ fn (mut c Checker) sql_expr(mut node ast.SqlExpr) ast.Type {
 	if node.is_insert {
 		node.typ = ast.int_type
 	}
-
+	last_cur_or_expr := c.cur_or_expr
+	c.cur_or_expr = &node.or_expr
 	c.check_orm_or_expr(mut node)
+	c.cur_or_expr = last_cur_or_expr
 
 	if node.is_insert {
 		return ast.int_type
@@ -211,8 +213,10 @@ fn (mut c Checker) sql_stmt(mut node ast.SqlStmt) ast.Type {
 	for mut line in node.lines {
 		c.sql_stmt_line(mut line)
 	}
-
+	last_cur_or_expr := c.cur_or_expr
+	c.cur_or_expr = &node.or_expr
 	c.check_orm_or_expr(mut node)
+	c.cur_or_expr = last_cur_or_expr
 
 	return ast.void_type
 }
@@ -605,7 +609,6 @@ fn (mut c Checker) check_orm_or_expr(mut expr ORMExpr) {
 			return
 		}
 	}
-
 	return_type := if mut expr is ast.SqlExpr {
 		expr.typ
 	} else {

vlib/v/gen/c/cgen.v

@@ -7177,7 +7177,10 @@ fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type ast.Ty
 	}
 	if or_block.kind == .block {
 		g.or_expr_return_type = return_type.clear_option_and_result()
-		g.writeln('\tIError err = ${cvar_name}${tmp_op}err;')
+		if !g.pref.skip_unused || or_block.err_used
+			|| (g.fn_decl != unsafe { nil } && (g.fn_decl.is_main || g.fn_decl.is_test)) {
+			g.writeln('\tIError err = ${cvar_name}${tmp_op}err;')
+		}
 
 		g.inside_or_block = true
 		defer {

vlib/v/gen/c/if.v

@@ -310,8 +310,12 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 			g.writeln('{')
 			// define `err` for the last branch after a `if val := opt {...}' guard
 			if is_guard && guard_idx == i - 1 {
-				cvar_name := guard_vars[guard_idx]
-				g.writeln('\tIError err = ${cvar_name}.err;')
+				if err_var := branch.scope.find_var('err') {
+					if !g.pref.skip_unused || err_var.is_used {
+						cvar_name := guard_vars[guard_idx]
+						g.writeln('\tIError err = ${cvar_name}.err;')
+					}
+				}
 			}
 		} else if branch.cond is ast.IfGuardExpr {
 			mut var_name := guard_vars[i]

vlib/v/gen/c/orm.v

@@ -1124,7 +1124,7 @@ fn (mut g Gen) write_orm_select(node ast.SqlExpr, connection_var_name string, re
 			field_var := '${tmp}.${c_name(field.name)}'
 			field_c_typ := g.styp(final_field_typ)
 			if sym.kind == .struct && sym.name != 'time.Time' {
-				mut sub := node.sub_structs[int(final_field_typ)]
+				mut sub := node.sub_structs[int(final_field_typ)] or { continue }
 				mut where_expr := sub.where_expr as ast.InfixExpr
 				mut ident := where_expr.right as ast.Ident
 				primitive_type_index := g.table.find_type('orm.Primitive')
@@ -1161,7 +1161,7 @@ fn (mut g Gen) write_orm_select(node ast.SqlExpr, connection_var_name string, re
 				} else {
 					verror('missing fkey attribute')
 				}
-				sub := node.sub_structs[final_field_typ]
+				sub := node.sub_structs[final_field_typ] or { continue }
 				if sub.has_where {
 					mut where_expr := sub.where_expr as ast.InfixExpr
 					mut left_where_expr := where_expr.left as ast.Ident

vlib/v/parser/comptime.v

@@ -536,10 +536,11 @@ fn (mut p Parser) comptime_selector(left ast.Expr) ast.Expr {
 		mut or_kind := ast.OrKind.absent
 		mut or_pos := p.tok.pos()
 		mut or_stmts := []ast.Stmt{}
+		mut or_scope := &ast.Scope(unsafe { nil })
 		if p.tok.kind == .key_orelse {
 			// `$method() or {}``
 			or_kind = .block
-			or_stmts, or_pos = p.or_block(.with_err_var)
+			or_stmts, or_pos, or_scope = p.or_block(.with_err_var)
 		}
 		return ast.ComptimeCall{
 			left:        left
@@ -554,6 +555,7 @@ fn (mut p Parser) comptime_selector(left ast.Expr) ast.Expr {
 				stmts: or_stmts
 				kind:  or_kind
 				pos:   or_pos
+				scope: or_scope
 			}
 		}
 	}