parser: Implement for niladic function calls without parens

Implement niladic function calls without parens, so that the following
Evy code is now valid:

	if rand1 > 0.5
	    print "Heads"
	end

	print read

	print rand1 rand1+10

which reads better than `if (rand1) > 0.5` etc.

Author: juliaogris

pkg/parser/ast.go

@@ -142,6 +142,10 @@ func (f *FuncDefStmt) Type() *Type {
 	return f.ReturnType
 }
 
+func (f *FuncDefStmt) isNiladic() bool {
+	return len(f.Params) == 0 && f.VariadicParam == nil
+}
+
 // EventHandlerStmt is an AST node that represents an event handler
 // definition. It includes the handler body, such as:
 //

pkg/parser/expression.go

@@ -49,28 +49,30 @@ var precedences = map[lexer.TokenType]precedence{
 
 func (p *parser) parseTopLevelExpr() Node {
 	tok := p.cur
-	if tok.Type == lexer.IDENT && p.funcs[tok.Literal] != nil {
-		return p.parseFuncCall()
+	if tok.Type == lexer.IDENT && p.funcs[tok.Literal] != nil && !p.funcs[tok.Literal].isNiladic() {
+		return p.parseFuncCall(true)
 	}
 	return p.parseExpr(lowestPrec)
 }
 
-func (p *parser) parseFuncCall() Node {
+func (p *parser) parseFuncCall(isTopLevel bool) Node {
 	fc := &FuncCall{token: p.cur, Name: p.cur.Literal}
 	p.advance() // advance past function name IDENT
 	funcDef := p.funcs[fc.Name]
 	funcDef.isCalled = true
 	fc.FuncDef = funcDef
-	fc.Arguments = p.parseExprList()
-	p.assertArgTypes(fc.FuncDef, fc.Arguments)
+	if isTopLevel || !funcDef.isNiladic() {
+		fc.Arguments = p.parseExprList()
+		p.assertArgTypes(fc.FuncDef, fc.Arguments)
+	}
 	return fc
 }
 
 func (p *parser) parseExpr(prec precedence) Node {
 	var left Node
 	switch p.cur.Type {
 	case lexer.IDENT:
-		left = p.lookupVar()
+		left = p.parseIdentExpr()
 	case lexer.STRING_LIT, lexer.NUM_LIT, lexer.TRUE, lexer.FALSE, lexer.LBRACKET, lexer.LCURLY:
 		left = p.parseLiteral()
 	case lexer.BANG, lexer.MINUS:
@@ -122,6 +124,14 @@ func (p *parser) isAtExprEnd() bool {
 	return p.isAtEOL()
 }
 
+func (p *parser) parseIdentExpr() Node {
+	funcDef := p.funcs[p.cur.Literal]
+	if funcDef != nil && funcDef.isNiladic() {
+		return p.parseFuncCall(false) // not a top-level func call
+	}
+	return p.lookupVar()
+}
+
 func (p *parser) parseUnaryExpr() Node {
 	tok := p.cur
 	unaryExp := &UnaryExpression{token: tok, Op: op(tok)}

pkg/parser/expression_test.go

@@ -73,6 +73,10 @@ func TestParseTopLevelExpression(t *testing.T) {
 		`print s[1]`:                  "print(any((s[1])))",
 		"print map2[s]":               "print(any((map2[s])))",
 
+		// niladic
+		`print rand1`:       "print(any(rand1()))",
+		`print rand1 rand1`: "print(any(rand1()), any(rand1()))",
+
 		// // Index expression
 		"arr[1]":        "(arr[1])",
 		"arr2[1][2]":    "((arr2[1])[2])",
@@ -300,3 +304,75 @@ func TestParseTopLevelExpressionErr(t *testing.T) {
 		assert.Equal(t, wantErr, got.Error(), "input: %s\nerrors:\n%s", input, parser.errors)
 	}
 }
+
+func TestParseNiladic(t *testing.T) {
+	inputs := map[string]string{
+		"rand1":       "print rand1",
+		"rand1-twice": "print rand1 rand1",
+		"rand1-expr":  "print rand1+10",
+		"rand1-toplevelexpr": `
+n := rand1+0.5
+print n
+`,
+		"rand1-toplevelexpr-space": `
+if rand1 > 0.5
+	print "big"
+end
+`,
+		"custom1": `
+func answer:string
+	return "42"
+end
+
+print answer`,
+	}
+
+	for name, input := range inputs {
+		t.Run(name, func(t *testing.T) {
+			parser := newParser(input, testBuiltins())
+			_ = parser.parse()
+			assertNoParseError(t, parser, input)
+		})
+	}
+}
+
+func TestParseNiladicErr(t *testing.T) {
+	type inputWithError struct {
+		input      string
+		wantErrMsg string
+	}
+	inputs := map[string]inputWithError{
+		"rand1-group": {
+			input:      "print (rand1 100)",
+			wantErrMsg: `line 1 column 14: expected ")", got ""`,
+		},
+		"custom1": {
+			input: `
+func answer
+	print "42"
+end
+
+len answer`,
+			wantErrMsg: `line 6 column 5: "len" takes 1st argument of type any, found none`,
+		},
+		"custom1-variadic": {
+			input: `
+func answer
+	print "42"
+end
+
+print answer`,
+			wantErrMsg: `line 6 column 7: "print" takes variadic arguments of type any, found none`,
+		},
+	}
+
+	for name, tc := range inputs {
+		t.Run(name, func(t *testing.T) {
+			parser := newParser(tc.input, testBuiltins())
+			_ = parser.parse()
+			assertParseError(t, parser, tc.input)
+			gotErr := parser.errors.Truncate(1)
+			assert.Equal(t, tc.wantErrMsg, gotErr.Error())
+		})
+	}
+}

pkg/parser/parser.go

@@ -564,7 +564,7 @@ func (p *parser) isFuncCall(tok *lexer.Token) bool {
 }
 
 func (p *parser) parseFunCallStatement() Node {
-	fc := p.parseFuncCall().(*FuncCall)
+	fc := p.parseFuncCall(true).(*FuncCall) // top-level funcCall
 	p.assertEOL()
 	fcs := &FuncCallStmt{token: fc.token, FuncCall: fc}
 	p.recordComment(fcs)

pkg/parser/parser_test.go

@@ -1785,6 +1785,11 @@ func testBuiltins() Builtins {
 			},
 			ReturnType: STRING_TYPE,
 		},
+		"rand1": {
+			Name:       "rand1",
+			Params:     []*Var{},
+			ReturnType: NUM_TYPE,
+		},
 	}
 	eventHandlers := map[string]*EventHandlerStmt{
 		"down": {