parser: Add unused var check

Add unused var check reporting an error if declared variable is never
used. This feature was yet again borrowed from go and piggy backed on
the scope data structure.

Author: juliaogris

pkg/parser/ast.go

@@ -81,9 +81,10 @@ type EventHandler struct {
 }
 
 type Var struct {
-	Token *lexer.Token
-	Name  string
-	T     *Type
+	Token  *lexer.Token
+	Name   string
+	T      *Type
+	isUsed bool
 }
 
 type BlockStatement struct {

pkg/parser/parser.go

@@ -115,6 +115,7 @@ func (p *Parser) parseProgram(scope *scope) *Program {
 			program.Statements = append(program.Statements, stmt)
 		}
 	}
+	p.validateScope(scope)
 	return program
 }
 
@@ -222,7 +223,6 @@ func (p *Parser) parseAssignmentStatement(scope *scope) Node {
 		p.advancePastNL()
 		return nil
 	}
-
 	target := p.parseAssignable(scope)
 	tok := p.cur
 	if target == nil {
@@ -390,7 +390,11 @@ func (p *Parser) parseTerm(scope *scope) Node {
 			p.advance()
 			return nil
 		}
-		return p.parseAssignable(scope)
+		assignable := p.parseAssignable(scope)
+		if v, ok := assignable.(*Var); ok {
+			v.isUsed = true
+		}
+		return assignable
 	}
 	if p.isLiteral() {
 		lit := p.parseLiteral(scope)
@@ -518,6 +522,15 @@ func (p *Parser) appendErrorForToken(message string, token *lexer.Token) {
 	p.errors = append(p.errors, Error{message: message, token: token})
 }
 
+// validateScope ensures all variables in scope have been used.
+func (p *Parser) validateScope(scope *scope) {
+	for _, v := range scope.vars {
+		if !v.isUsed {
+			p.appendErrorForToken("'"+v.Name+"' declared but not used", v.Token)
+		}
+	}
+}
+
 func (p *Parser) parseBlock(scope *scope) *BlockStatement {
 	endTokens := map[lexer.TokenType]bool{lexer.END: true, lexer.EOF: true}
 	return p.parseBlockWithEndTokens(scope, endTokens)
@@ -548,6 +561,7 @@ func (p *Parser) parseBlockWithEndTokens(scope *scope, endTokens map[lexer.Token
 	if len(block.Statements) == 0 {
 		p.appendErrorForToken("at least one statement is required here", block.Token)
 	}
+	p.validateScope(scope)
 	return block
 }
 

pkg/parser/parser_test.go

@@ -10,14 +10,15 @@ import (
 func TestParseDeclaration(t *testing.T) {
 	tests := map[string][]string{
 		"a := 1":     {"a=1"},
-		"b:bool":     {"b=false"},
-		"\nb:bool\n": {"b=false"},
+		"a:bool":     {"a=false"},
+		"\na:bool\n": {"a=false"},
 		`a := "abc"
 		b:bool
-		c := true`: {"a='abc'", "b=false", "c=true"},
+		c := true
+		print a b c`: {"a='abc'", "b=false", "c=true", "print(a, b, c)"},
 		"a:num[]":                      {"a=[]"},
 		"a:num[]{}":                    {"a={}"},
-		"abc:any[]{}":                  {"abc={}"},
+		"a:any[]{}":                    {"a={}"},
 		"a := bool[true]":              {"a=[true]"},
 		"a := num[]":                   {"a=[]"},
 		"a := num[][num[1 2]num[3 4]]": {"a=[[1, 2], [3, 4]]"},
@@ -32,6 +33,8 @@ func TestParseDeclaration(t *testing.T) {
 		"a := num{}[num{a:1}]":                          {"a=[{a:1}]"},
 	}
 	for input, wantSlice := range tests {
+		input += "\n print a"
+		wantSlice = append(wantSlice, "print(a)")
 		want := strings.Join(wantSlice, "\n") + "\n"
 		parser := New(input, testBuiltins())
 		got := parser.Parse()
@@ -91,14 +94,14 @@ func TestParseDeclarationError(t *testing.T) {
 
 func TestFunctionCall(t *testing.T) {
 	tests := map[string][]string{
-		"print":               {"print()"},
-		"print 123":           {"print(123)"},
-		`print 123 "abc"`:     {"print(123, 'abc')"},
-		"a:=1 \n print a":     {"a=1", "print(a)"},
-		`a := len "abc"`:      {"a=len('abc')"},
-		`len "abc"`:           {"len('abc')"},
-		`len num[]`:           {"len([])"},
-		"a:string \n print a": {"a=''", "print(a)"},
+		"print":                          {"print()"},
+		"print 123":                      {"print(123)"},
+		`print 123 "abc"`:                {"print(123, 'abc')"},
+		"a:=1 \n print a":                {"a=1", "print(a)"},
+		`a := len "abc"` + " \n print a": {"a=len('abc')", "print(a)"},
+		`len "abc"`:                      {"len('abc')"},
+		`len num[]`:                      {"len([])"},
+		"a:string \n print a":            {"a=''", "print(a)"},
 		`a:=true
 		b:string
 		print a b`: {"a=true", "b=''", "print(a, b)"},
@@ -177,12 +180,14 @@ print('TRUE')
 func TestToplevelExprFuncCall(t *testing.T) {
 	input := `
 x := len "123"
+print x
 `
 	parser := New(input, testBuiltins())
 	got := parser.Parse()
 	assertNoParseError(t, parser, input)
 	want := `
 x=len('123')
+print(x)
 `[1:]
 	assert.Equal(t, want, got.String())
 }
@@ -315,14 +320,17 @@ func TestFuncAssignment(t *testing.T) {
 a := 1
 b:num
 b = a
+print b
 `, `
 a:num
 b:num
 b = a
+print b
 `, `
 a:num
 b:any
 b = a
+print b
 `,
 	}
 	for _, input := range inputs {
@@ -376,22 +384,35 @@ func TestScope(t *testing.T) {
 x := 1
 func foo
 	x := "abc"
+	print x
 end
+print x
 `, `
 x := 1
 func foo x:string
 	x = "abc"
+	print x
+end
+print x
+`, `
+x := 1
+func foo
+	x = 2
+	print x
 end
 `, `
 x := 1
 func foo x:string...
 	print x
 end
+print x
 `, `
 x := 1
 if true
 	x := "abc" // block scope
+	print x
 end
+print x
 `,
 	}
 	for _, input := range inputs {
@@ -401,6 +422,103 @@ end
 	}
 }
 
+func TestUnusedErr(t *testing.T) {
+	inputs := map[string]string{
+		`
+x := 1
+`: "line 2 column 1: 'x' declared but not used",
+		`
+x := 1
+if true
+	x := 1
+end
+print x
+`: "line 4 column 2: 'x' declared but not used",
+		`
+x := 1
+if true
+	x := 1
+	print x
+end
+`: "line 2 column 1: 'x' declared but not used",
+		`
+x := 1
+if true
+	print "foo"
+else
+	x := 1
+	print x
+end
+`: "line 2 column 1: 'x' declared but not used",
+		`
+x := 1
+if true
+	print "foo"
+else
+	x := 1
+end
+print x
+`: "line 6 column 2: 'x' declared but not used",
+		`
+x := 1
+if true
+	print "foo"
+else if true
+	x := 1
+end
+print x
+`: "line 6 column 2: 'x' declared but not used",
+		`
+x := 1
+for i := range 10
+	x := 2
+	print x
+end
+`: "line 2 column 1: 'x' declared but not used",
+		`
+x := 1
+for i := range 10
+	x := 2
+end
+print x
+`: "line 4 column 2: 'x' declared but not used",
+		`
+x := 1
+while true
+	x := 2
+	print x
+end
+`: "line 2 column 1: 'x' declared but not used",
+		`
+x := 1
+while true
+	x := 2
+end
+print x
+`: "line 4 column 2: 'x' declared but not used",
+		`
+x := 1
+func foo
+	x := 2
+end
+print x
+`: "line 4 column 2: 'x' declared but not used",
+		`
+x := 1
+func foo
+	x := 2
+	print x
+end
+`: "line 2 column 1: 'x' declared but not used",
+	}
+	for input, wantErr := range inputs {
+		parser := New(input, testBuiltins())
+		_ = parser.Parse()
+		assertParseError(t, parser, input)
+		assert.Equal(t, wantErr, parser.MaxErrorsString(1))
+	}
+}
+
 func TestScopeErr(t *testing.T) {
 	inputs := map[string]string{
 		`