parser: Add assignment parsing

Add assignment parsing and assignment AST node. Extract parseAssignable
from parseTerm to reuse here. This will be extended by indexed and
field selector expressions.

Author: juliaogris

pkg/parser/ast.go

@@ -36,6 +36,12 @@ type Declaration struct {
 	Value Node // literal, expression, assignable, ...
 }
 
+type Assignment struct {
+	Token  *lexer.Token
+	Target Node // Variable, index or field expression
+	Value  Node // literal, expression, assignable, ...
+}
+
 type Return struct {
 	Token *lexer.Token
 	Value Node // literal, expression, assignable, ...
@@ -141,6 +147,13 @@ func (r *Return) Type() *Type {
 	return r.T
 }
 
+func (a *Assignment) String() string {
+	return a.Target.String() + " = " + a.Value.String()
+}
+func (a *Assignment) Type() *Type {
+	return a.Target.Type()
+}
+
 func (f *FuncDecl) String() string {
 	s := make([]string, len(f.Params))
 	for i, param := range f.Params {

pkg/parser/parser.go

@@ -168,7 +168,7 @@ func (p *Parser) parseStatement(scope *scope) Node {
 	case lexer.IDENT:
 		switch p.peek.Type {
 		case lexer.ASSIGN, lexer.LBRACKET, lexer.DOT:
-			return p.parseAssignStatement(scope) // TODO
+			return p.parseAssignmentStatement(scope)
 		case lexer.COLON:
 			return p.parseTypedDeclStatement(scope)
 		case lexer.DECLARE:
@@ -196,9 +196,44 @@ func (p *Parser) parseStatement(scope *scope) Node {
 	return nil
 }
 
-func (p *Parser) parseAssignStatement(scope *scope) Node {
+func (p *Parser) parseAssignmentStatement(scope *scope) Node {
+	if p.isFuncCall(p.cur) {
+		p.appendError("cannot assign to '" + p.cur.Literal + "' as it is a function not a variable")
+		p.advancePastNL()
+		return nil
+	}
+
+	target := p.parseAssignable(scope)
+	tok := p.cur
+	if target == nil {
+		p.advancePastNL()
+		return nil
+	}
+	p.assertToken(lexer.ASSIGN)
+	p.advance()
+	value := p.parseTopLevelExpression(scope)
+	if value == nil {
+		p.advancePastNL()
+		return nil
+	}
+	if !target.Type().Accepts(value.Type()) {
+		msg := "'" + target.String() + "' accepts values of type " + target.Type().Format() + ", found " + value.Type().Format()
+		p.appendErrorForToken(msg, tok)
+	}
+	p.assertEOL()
 	p.advancePastNL()
-	return nil
+	return &Assignment{Token: tok, Target: target, Value: value}
+}
+
+func (p *Parser) parseAssignable(scope *scope) Node {
+	name := p.cur.Literal
+	p.advance()
+	v, ok := scope.get(name)
+	if !ok {
+		p.appendError("unknown variable name '" + name + "'")
+		return nil
+	}
+	return v
 }
 
 func (p *Parser) parseFuncDeclSignature() *FuncDecl {
@@ -329,18 +364,12 @@ func (p *Parser) parseTerm(scope *scope) Node {
 	//TODO: UNARY_OP Term; composite literals; assignable; slice; type_assertion; "(" toplevel_expr ")"
 	tt := p.cur.TokenType()
 	if tt == lexer.IDENT {
-		varName := p.cur.Literal
-		p.advance()
-		v, ok := scope.get(varName)
-		if !ok {
-			if _, ok := p.funcs[varName]; ok {
-				p.appendError("function call must be parenthesized: (" + varName + " ...)")
-			} else {
-				p.appendError("unknown variable name '" + varName + "'")
-			}
+		if p.isFuncCall(p.cur) {
+			p.appendError("function call must be parenthesized: (" + p.cur.Literal + " ...)")
+			p.advance()
 			return nil
 		}
-		return v
+		return p.parseAssignable(scope)
 	}
 	if p.isLiteral() {
 		lit := p.parseLiteral(scope)

pkg/parser/parser_test.go

@@ -129,6 +129,7 @@ func TestFunctionCallError(t *testing.T) {
 		`a := f0`:    "line 1 column 8: invalid declaration, function 'f0' has no return value",
 		`f0 "arg"`:   "line 1 column 9: 'f0' takes 0 arguments, found 1",
 		`f2`:         "line 1 column 3: 'f2' takes 1 argument, found 0",
+		`f2 f1`:      "line 1 column 4: function call must be parenthesized: (f1 ...)",
 		`f1 "arg"`:   "line 1 column 9: 'f1' takes variadic arguments of type 'num', found 'string'",
 		`f3 1 2`:     "line 1 column 7: 'f3' takes 2nd argument of type 'string', found 'num'",
 		`f3 "1" "2"`: "line 1 column 11: 'f3' takes 1st argument of type 'num', found 'string'",
@@ -209,6 +210,65 @@ end
 	assert.Equal(t, "return n1", returnStmt.String())
 }
 
+func TestFuncAssignment(t *testing.T) {
+	inputs := []string{`
+a := 1
+b:num
+b = a
+`, `
+a:num
+b:num
+b = a
+`, `
+a:num
+b:any
+b = a
+`,
+	}
+	for _, input := range inputs {
+		parser := New(input, testBuiltins())
+		_ = parser.Parse()
+		assertNoParseError(t, parser, input)
+	}
+}
+
+func TestFuncAssignmentErr(t *testing.T) {
+	inputs := map[string]string{`
+b:num
+b = true
+`: "line 3 column 3: 'b' accepts values of type num, found bool",
+		`
+a:= 1
+a = b
+`: "line 3 column 6: unknown variable name 'b'",
+		`
+a:= 1
+b = a
+`: "line 3 column 3: unknown variable name 'b'",
+		`
+a:= 1
+a = num[]
+`: "line 3 column 3: 'a' accepts values of type num, found num[]",
+		`
+a:num
+b:any
+a = b
+`: "line 4 column 3: 'a' accepts values of type num, found any",
+		`
+func fn
+	return true
+end
+fn = 3
+`: "line 5 column 1: cannot assign to 'fn' as it is a function not a variable",
+	}
+	for input, wantErr := range inputs {
+		parser := New(input, testBuiltins())
+		_ = parser.Parse()
+		assertParseError(t, parser, input)
+		assert.Equal(t, wantErr, parser.MaxErrorsString(1))
+	}
+}
+
 func TestScope(t *testing.T) {
 	inputs := []string{`
 x := 1