parser: simplify unused vars & add loop/if vars etc

joe-conigliaro · joe-conigliaro · commit 9f76a7b25049 · 2020-04-27T23:16:31.000+10:00
diff --git a/vlib/builtin/string.v b/vlib/builtin/string.v
@@ -832,7 +832,7 @@ fn (ar []string) contains(val string) bool {
 
 // TODO generic
 fn (ar []int) contains(val int) bool {
-	for i, s in ar {
+	for s in ar {
 		if s == val {
 			return true
 		}
@@ -1206,7 +1206,7 @@ pub fn (a []string) join(del string) string {
 		return ''
 	}
 	mut len := 0
-	for i, val in a {
+	for val in a {
 		len += val.len + del.len
 	}
 	len -= del.len
diff --git a/vlib/os/os.v b/vlib/os/os.v
@@ -1061,7 +1061,7 @@ pub fn walk_ext(path, ext string) []string {
 	}
 	mut res := []string{}
 	separator := if path.ends_with(os.path_separator) { '' } else { os.path_separator }
-	for i, file in files {
+	for file in files {
 		if file.starts_with('.') {
 			continue
 		}
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
@@ -270,12 +270,13 @@ pub struct Stmt {
 */
 pub struct Var {
 pub:
-	name   string
-	expr   Expr
-	is_mut bool
+	name    string
+	expr    Expr
+	is_mut  bool
 mut:
-	typ    table.Type
-	pos    token.Position
+	typ     table.Type
+	pos     token.Position
+	is_used bool
 }
 
 pub struct GlobalDecl {
diff --git a/vlib/v/ast/scope.v b/vlib/v/ast/scope.v
@@ -12,15 +12,9 @@ mut:
 	children  []&Scope
 	start_pos int
 	end_pos   int
-	unused_vars map[string]UnusedVar
 	objects   map[string]ScopeObject
 }
 
-pub struct UnusedVar {
-	name string
-	pos token.Position
-}
-
 pub fn new_scope(parent &Scope, start_pos int) &Scope {
 	return &ast.Scope{
 		parent: parent
@@ -63,25 +57,25 @@ pub fn (s &Scope) is_known(name string) bool {
 	return false
 }
 
-pub fn (s &Scope) find_var(name string) ?Var {
+pub fn (s &Scope) find_var(name string) ?&Var {
 	if obj := s.find(name) {
 		v := ScopeObject(obj)
 		match v {
 			Var {
-				return *it
+				return it
 			}
 			else {}
 		}
 	}
 	return none
 }
 
-pub fn (s &Scope) find_const(name string) ?ConstField {
+pub fn (s &Scope) find_const(name string) ?&ConstField {
 	if obj := s.find(name) {
 		cf := ScopeObject(obj)
 		match cf {
 			ConstField {
-				return *it
+				return it
 			}
 			else {}
 		}
@@ -112,37 +106,13 @@ pub fn (s mut Scope) register(name string, obj ScopeObject) {
 	if name == '_' {
 		return
 	}
-	if x := s.find(name) {
+	if _ := s.find(name) {
 		// println('existing obect: $name')
 		return
 	}
 	s.objects[name] = obj
 }
 
-pub fn (s mut Scope) register_unused_var(name string, pos token.Position) {
-	s.unused_vars[name] = UnusedVar{name, pos}
-}
-
-pub fn (s mut Scope) remove_unused_var(name string) {
-	mut sc := s
-	for !isnil(sc) {
-		sc.unused_vars.delete(name)
-		sc = sc.parent
-	}
-}
-
-pub fn (s mut Scope) unused_vars() []UnusedVar {
-	ret := []UnusedVar{}
-	for _, v in s.unused_vars {
-		ret << v
-	}
-	return ret
-}
-
-pub fn (s mut Scope) clear_unused_vars() {
-	s.unused_vars = map[string]UnusedVar
-}
-
 pub fn (s &Scope) outermost() &Scope {
 	mut sc := s
 	for !isnil(sc.parent) {
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -203,7 +203,7 @@ pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {
 		}
 		c.error('struct name must begin with capital letter', pos)
 	}
-	for fi, field in decl.fields {
+	for field in decl.fields {
 		sym := c.table.get_type_symbol(field.typ)
 		if sym.kind == .placeholder && !decl.is_c && !sym.name.starts_with('C.') {
 			c.error('unknown type `$sym.name`', field.pos)
@@ -554,7 +554,7 @@ pub fn (mut c Checker) call_method(call_expr mut ast.CallExpr) table.Type {
 			mut scope := c.file.scope.innermost(call_expr.pos.pos)
 			scope.update_var_type('it', array_info.elem_type)
 		}
-		for i, arg in call_expr.args {
+		for arg in call_expr.args {
 			c.expr(arg.expr)
 		}
 		// need to return `array_xxx` instead of `array`
diff --git a/vlib/v/gen/cgen.v b/vlib/v/gen/cgen.v
@@ -480,7 +480,7 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 			g.typedefs.writeln('typedef enum {')
 			mut cur_enum_expr := ''
 			mut cur_enum_offset := 0
-			for j, field in it.fields {
+			for field in it.fields {
 				g.typedefs.write('\t${enum_name}_${field.name}')
 				if field.has_expr {
 					g.typedefs.write(' = ')
@@ -1918,7 +1918,7 @@ fn (mut g Gen) return_statement(node ast.Return) {
 }
 
 fn (mut g Gen) const_decl(node ast.ConstDecl) {
-	for i, field in node.fields {
+	for field in node.fields {
 		name := c_name(field.name)
 		// TODO hack. Cut the generated value and paste it into definitions.
 		pos := g.out.len
@@ -3061,7 +3061,7 @@ fn (mut g Gen) gen_str_for_enum(info table.Enum, styp, str_fn_name string) {
 	g.definitions.writeln('string ${str_fn_name}($styp it); // auto')
 	g.auto_str_funcs.writeln('string ${str_fn_name}($styp it) { /* gen_str_for_enum */')
 	g.auto_str_funcs.writeln('\tswitch(it) {')
-	for i, val in info.vals {
+	for val in info.vals {
 		g.auto_str_funcs.writeln('\t\tcase ${s}_$val: return tos3("$val");')
 	}
 	g.auto_str_funcs.writeln('\t\tdefault: return tos3("unknown enum value");')
@@ -3075,7 +3075,7 @@ fn (mut g Gen) gen_str_for_struct(info table.Struct, styp, str_fn_name string) {
 	mut fnames2strfunc := {
 		'': ''
 	} // map[string]string // TODO vfmt bug
-	for i, field in info.fields {
+	for field in info.fields {
 		sym := g.table.get_type_symbol(field.typ)
 		if sym.kind in [.struct_, .array, .array_fixed, .map, .enum_] {
 			field_styp := g.typ(field.typ)
diff --git a/vlib/v/gen/fn.v b/vlib/v/gen/fn.v
@@ -426,7 +426,7 @@ fn (mut g Gen) call_args(args []ast.CallArg, expected_types []table.Type) {
 	is_forwarding_varg := args.len > 0 && args[args.len - 1].typ.flag_is(.variadic)
 	gen_vargs := is_variadic && !is_forwarding_varg
 	mut arg_no := 0
-	for i, arg in args {
+	for arg in args {
 		if gen_vargs && arg_no == expected_types.len - 1 {
 			break
 		}
diff --git a/vlib/v/gen/x64/gen.v b/vlib/v/gen/x64/gen.v
@@ -600,7 +600,7 @@ fn (mut g Gen) allocate_var(name string, size, initial_val int) {
 
 fn (mut g Gen) assign_stmt(node ast.AssignStmt) {
 	// `a := 1` | `a,b := 1,2`
-	for i, ident in node.left {
+	for ident in node.left {
 		match node.right[0] {
 			ast.IntegerLiteral {
 				g.allocate_var(ident.name, 4, it.val.int())
diff --git a/vlib/v/parser/assign.v b/vlib/v/parser/assign.v
@@ -32,11 +32,13 @@ fn (mut p Parser) assign_stmt() ast.Stmt {
 					name: ident.name
 					expr: exprs[i]
 					is_mut: ident.is_mut || p.inside_for
+					pos: ident.pos
 				})
 			} else {
 				p.scope.register(ident.name, ast.Var{
 					name: ident.name
 					is_mut: ident.is_mut || p.inside_for
+					pos: ident.pos
 				})
 			}
 		}
diff --git a/vlib/v/parser/fn.v b/vlib/v/parser/fn.v
@@ -37,10 +37,14 @@ pub fn (mut p Parser) call_expr(is_c, is_js bool, mod string) ast.CallExpr {
 		p.scope.register('err', ast.Var{
 			name: 'err'
 			typ: table.string_type
+			pos: p.tok.position()
+			is_used: true
 		})
 		p.scope.register('errcode', ast.Var{
 			name: 'errcode'
 			typ: table.int_type
+			pos: p.tok.position()
+			is_used: true
 		})
 		is_or_block_used = true
 		or_stmts = p.parse_block_no_scope()
@@ -164,6 +168,8 @@ fn (mut p Parser) fn_decl() ast.FnDecl {
 			name: arg.name
 			typ: arg.typ
 			is_mut: arg.is_mut
+			pos: p.tok.position()
+			is_used: true
 		})
 		// Do not allow `mut` with simple types
 		// TODO move to checker?
@@ -264,6 +270,8 @@ fn (mut p Parser) anon_fn() ast.AnonFn {
 		p.scope.register(arg.name, ast.Var{
 			name: arg.name
 			typ: arg.typ
+			pos: p.tok.position()
+			is_used: true
 		})
 	}
 	mut return_type := table.void_type
diff --git a/vlib/v/parser/for.v b/vlib/v/parser/for.v
@@ -67,12 +67,16 @@ fn (mut p Parser) for_stmt() ast.Stmt {
 		}
 	} else if p.peek_tok.kind in [.key_in, .comma] {
 		// `for i in vals`, `for i in start .. end`
+		mut val_var_pos := p.tok.position()
 		mut key_var_name := ''
 		mut val_var_name := p.check_name()
 		if p.tok.kind == .comma {
 			p.check(.comma)
+			key_var_pos := val_var_pos
+			val_var_pos = p.tok.position()
 			key_var_name = val_var_name
 			val_var_name = p.check_name()
+			
 			if p.scope.known_var(key_var_name) {
 				p.error('redefinition of key iteration variable `$key_var_name`')
 			}
@@ -82,6 +86,7 @@ fn (mut p Parser) for_stmt() ast.Stmt {
 			p.scope.register(key_var_name, ast.Var{
 				name: key_var_name
 				typ: table.int_type
+				pos: key_var_pos
 			})
 		} else if p.scope.known_var(val_var_name) {
 			p.error('redefinition of value iteration variable `$val_var_name`')
@@ -104,11 +109,13 @@ fn (mut p Parser) for_stmt() ast.Stmt {
 			p.scope.register(val_var_name, ast.Var{
 				name: val_var_name
 				typ: table.int_type
+				pos: val_var_pos
 			})
 		} else {
 			// this type will be set in checker
 			p.scope.register(val_var_name, ast.Var{
 				name: val_var_name
+				pos: val_var_pos
 			})
 		}
 		p.inside_for = false
diff --git a/vlib/v/parser/if.v b/vlib/v/parser/if.v
@@ -43,12 +43,14 @@ fn (mut p Parser) if_expr() ast.IfExpr {
 		if p.peek_tok.kind == .decl_assign {
 			is_or = true
 			p.open_scope()
+			var_pos := p.tok.position()
 			var_name := p.check_name()
 			p.check(.decl_assign)
 			expr := p.expr(0)
 			p.scope.register(var_name, ast.Var{
 				name: var_name
 				expr: expr
+				pos: var_pos
 			})
 			cond = ast.IfGuardExpr{
 				var_name: var_name
@@ -89,6 +91,7 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 	if is_mut {
 		p.next()
 	}
+	cond_pos := p.tok.position()
 	cond := p.expr(0)
 	p.inside_match = false
 	p.check(.lcbr)
@@ -119,6 +122,8 @@ fn (mut p Parser) match_expr() ast.MatchExpr {
 			p.scope.register('it', ast.Var{
 				name: 'it'
 				typ: typ.to_ptr()
+				pos: cond_pos
+				is_used: true
 			})
 			// TODO
 			if p.tok.kind == .comma {
diff --git a/vlib/v/parser/parser.v b/vlib/v/parser/parser.v
diff --git a/vlib/v/parser/pratt.v b/vlib/v/parser/pratt.v
diff --git a/vlib/v/table/atypes.v b/vlib/v/table/atypes.v

Original file line number	Diff line number	Diff line change
`@@ -832,7 +832,7 @@ fn (ar []string) contains(val string) bool {`
`832`	`832`
`833`	`833`	`// TODO generic`
`834`	`834`	`fn (ar []int) contains(val int) bool {`
`835`		`- for i, s in ar {`
	`835`	`+ for s in ar {`
`836`	`836`	`if s == val {`
`837`	`837`	`return true`
`838`	`838`	`}`
`@@ -1206,7 +1206,7 @@ pub fn (a []string) join(del string) string {`
`1206`	`1206`	`return ''`
`1207`	`1207`	`}`
`1208`	`1208`	`mut len := 0`
`1209`		`- for i, val in a {`
	`1209`	`+ for val in a {`
`1210`	`1210`	`len += val.len + del.len`
`1211`	`1211`	`}`
`1212`	`1212`	`len -= del.len`
Original file line number	Diff line number	Diff line change
`@@ -1061,7 +1061,7 @@ pub fn walk_ext(path, ext string) []string {`
`1061`	`1061`	`}`
`1062`	`1062`	`mut res := []string{}`
`1063`	`1063`	`separator := if path.ends_with(os.path_separator) { '' } else { os.path_separator }`
`1064`		`- for i, file in files {`
	`1064`	`+ for file in files {`
`1065`	`1065`	`if file.starts_with('.') {`
`1066`	`1066`	`continue`
`1067`	`1067`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ pub fn (mut c Checker) struct_decl(decl ast.StructDecl) {`
`203`	`203`	`}`
`204`	`204`	`c.error('struct name must begin with capital letter', pos)`
`205`	`205`	`}`
`206`		`- for fi, field in decl.fields {`
	`206`	`+ for field in decl.fields {`
`207`	`207`	`sym := c.table.get_type_symbol(field.typ)`
`208`	`208`	`if sym.kind == .placeholder && !decl.is_c && !sym.name.starts_with('C.') {`
`209`	`209`	c.error('unknown type `$sym.name`', field.pos)
`@@ -554,7 +554,7 @@ pub fn (mut c Checker) call_method(call_expr mut ast.CallExpr) table.Type {`
`554`	`554`	`mut scope := c.file.scope.innermost(call_expr.pos.pos)`
`555`	`555`	`scope.update_var_type('it', array_info.elem_type)`
`556`	`556`	`}`
`557`		`- for i, arg in call_expr.args {`
	`557`	`+ for arg in call_expr.args {`
`558`	`558`	`c.expr(arg.expr)`
`559`	`559`	`}`
`560`	`560`	// need to return `array_xxx` instead of `array`
Original file line number	Diff line number	Diff line change
`@@ -426,7 +426,7 @@ fn (mut g Gen) call_args(args []ast.CallArg, expected_types []table.Type) {`
`426`	`426`	`is_forwarding_varg := args.len > 0 && args[args.len - 1].typ.flag_is(.variadic)`
`427`	`427`	`gen_vargs := is_variadic && !is_forwarding_varg`
`428`	`428`	`mut arg_no := 0`
`429`		`- for i, arg in args {`
	`429`	`+ for arg in args {`
`430`	`430`	`if gen_vargs && arg_no == expected_types.len - 1 {`
`431`	`431`	`break`
`432`	`432`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,11 +32,13 @@ fn (mut p Parser) assign_stmt() ast.Stmt {`
`32`	`32`	`name: ident.name`
`33`	`33`	`expr: exprs[i]`
`34`	`34`	`is_mut: ident.is_mut \|\| p.inside_for`
	`35`	`+ pos: ident.pos`
`35`	`36`	`})`
`36`	`37`	`} else {`
`37`	`38`	`p.scope.register(ident.name, ast.Var{`
`38`	`39`	`name: ident.name`
`39`	`40`	`is_mut: ident.is_mut \|\| p.inside_for`
	`41`	`+ pos: ident.pos`
`40`	`42`	`})`
`41`	`43`	`}`
`42`	`44`	`}`