Only allow if on precedence == 0

Author: antonmedv

parser/parser.go

@@ -110,7 +110,7 @@ func ParseWithConfig(input string, config *conf.Config) (*Tree, error) {
 		config:  config,
 	}
 
-	node := p.parseExpression(0)
+	node := p.parseSequenceExpression()
 
 	if !p.current.Is(EOF) {
 		p.error("unexpected token %v", p.current)
@@ -190,7 +190,7 @@ func (p *parser) parseExpression(precedence int) Node {
 		return p.parseVariableDeclaration()
 	}
 
-	if p.current.Is(Operator, "if") {
+	if precedence == 0 && p.current.Is(Operator, "if") {
 		return p.parseConditionalIf()
 	}
 
@@ -290,7 +290,7 @@ func (p *parser) parseVariableDeclaration() Node {
 	p.expect(Operator, "=")
 	value := p.parseExpression(0)
 	p.expect(Operator, ";")
-	node := p.parseExpression(0)
+	node := p.parseSequenceExpression()
 	return p.createNode(&VariableDeclaratorNode{
 		Name:  variableName.Value,
 		Value: value,
@@ -364,7 +364,7 @@ func (p *parser) parsePrimary() Node {
 
 	if token.Is(Bracket, "(") {
 		p.next()
-		expr := p.parseExpression(0)
+		expr := p.parseSequenceExpression()
 		p.expect(Bracket, ")") // "an opened parenthesis is not properly closed"
 		return p.parsePostfixExpression(expr)
 	}
@@ -607,17 +607,22 @@ func (p *parser) parseArguments(arguments []Node) []Node {
 
 func (p *parser) parsePredicate() Node {
 	startToken := p.current
-	expectClosingBracket := false
+	withBrackets := false
 	if p.current.Is(Bracket, "{") {
 		p.next()
-		expectClosingBracket = true
+		withBrackets = true
 	}
 
 	p.depth++
-	node := p.parseExpression(0)
+	var node Node
+	if withBrackets {
+		node = p.parseSequenceExpression()
+	} else {
+		node = p.parseExpression(0)
+	}
 	p.depth--
 
-	if expectClosingBracket {
+	if withBrackets {
 		p.expect(Bracket, "}")
 	}
 	predicateNode := p.createNode(&PredicateNode{

parser/parser_test.go

@@ -659,6 +659,29 @@ world`},
 				Exp1: &BoolNode{Value: true},
 				Exp2: &IdentifierNode{Value: "x"}},
 		},
+		{
+			"1; 2; 3",
+			&SequenceNode{
+				Nodes: []Node{
+					&IntegerNode{Value: 1},
+					&IntegerNode{Value: 2},
+					&IntegerNode{Value: 3},
+				},
+			},
+		},
+		{
+			"1; (2; 3)",
+			&SequenceNode{
+				Nodes: []Node{
+					&IntegerNode{Value: 1},
+					&SequenceNode{
+						Nodes: []Node{
+							&IntegerNode{Value: 2},
+							&IntegerNode{Value: 3}},
+					},
+				},
+			},
+		},
 		{
 			"true ? 1; 2; 3 : 4",
 			&ConditionalNode{
@@ -707,6 +730,115 @@ world`},
 						&IntegerNode{Value: 5},
 						&IntegerNode{Value: 6}}}},
 		},
+		{
+			`all(ls, if true { 1 } else { 2 })`,
+			&BuiltinNode{
+				Name: "all",
+				Arguments: []Node{
+					&IdentifierNode{Value: "ls"},
+					&PredicateNode{
+						Node: &ConditionalNode{
+							Cond: &BoolNode{Value: true},
+							Exp1: &IntegerNode{Value: 1},
+							Exp2: &IntegerNode{Value: 2}}}}},
+		},
+		{
+			`let x = if true { 1 } else { 2 }; x`,
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &ConditionalNode{
+					Cond: &BoolNode{Value: true},
+					Exp1: &IntegerNode{Value: 1},
+					Exp2: &IntegerNode{Value: 2}},
+				Expr: &IdentifierNode{Value: "x"}},
+		},
+		{
+			`call(if true { 1 } else { 2 })`,
+			&CallNode{
+				Callee: &IdentifierNode{Value: "call"},
+				Arguments: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &IntegerNode{Value: 1},
+						Exp2: &IntegerNode{Value: 2}}}},
+		},
+		{
+			`[if true { 1 } else { 2 }]`,
+			&ArrayNode{
+				Nodes: []Node{
+					&ConditionalNode{
+						Cond: &BoolNode{Value: true},
+						Exp1: &IntegerNode{Value: 1},
+						Exp2: &IntegerNode{Value: 2}}}},
+		},
+		{
+			`map(ls, { 1; 2; 3 })`,
+			&BuiltinNode{
+				Name: "map",
+				Arguments: []Node{
+					&IdentifierNode{Value: "ls"},
+					&PredicateNode{
+						Node: &SequenceNode{
+							Nodes: []Node{
+								&IntegerNode{Value: 1},
+								&IntegerNode{Value: 2},
+								&IntegerNode{Value: 3},
+							},
+						},
+					},
+				}},
+		},
+		{
+			`let x = 1; 2; 3 + x`,
+			&VariableDeclaratorNode{
+				Name:  "x",
+				Value: &IntegerNode{Value: 1},
+				Expr: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 2},
+						&BinaryNode{
+							Operator: "+",
+							Left:     &IntegerNode{Value: 3},
+							Right:    &IdentifierNode{Value: "x"},
+						},
+					},
+				},
+			},
+		},
+		{
+			`let x = 1; let y = 2; 3; 4; x + y`,
+			&VariableDeclaratorNode{
+				Name:  "x",
+				Value: &IntegerNode{Value: 1},
+				Expr: &VariableDeclaratorNode{
+					Name:  "y",
+					Value: &IntegerNode{Value: 2},
+					Expr: &SequenceNode{
+						Nodes: []Node{
+							&IntegerNode{Value: 3},
+							&IntegerNode{Value: 4},
+							&BinaryNode{
+								Operator: "+",
+								Left:     &IdentifierNode{Value: "x"},
+								Right:    &IdentifierNode{Value: "y"},
+							},
+						},
+					}}},
+		},
+		{
+			`let x = (1; 2; 3); x`,
+			&VariableDeclaratorNode{
+				Name: "x",
+				Value: &SequenceNode{
+					Nodes: []Node{
+						&IntegerNode{Value: 1},
+						&IntegerNode{Value: 2},
+						&IntegerNode{Value: 3},
+					},
+				},
+				Expr: &IdentifierNode{Value: "x"},
+			},
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.input, func(t *testing.T) {
@@ -788,6 +920,27 @@ func TestParse_error(t *testing.T) {
 		{`1 not == [1, 2, 5]`, `unexpected token Operator("==") (1:7)
  | 1 not == [1, 2, 5]
  | ......^`},
+		{`foo(1; 2; 3)`, `unexpected token Operator(";") (1:6)
+ | foo(1; 2; 3)
+ | .....^`},
+		{
+			`map(ls, 1; 2; 3)`,
+			`unexpected token Operator(";") (1:10)
+ | map(ls, 1; 2; 3)
+ | .........^`,
+		},
+		{
+			`[1; 2; 3]`,
+			`unexpected token Operator(";") (1:3)
+ | [1; 2; 3]
+ | ..^`,
+		},
+		{
+			`1 + if true { 2 } else { 3 }`,
+			`unexpected token Operator("if") (1:5)
+ | 1 + if true { 2 } else { 3 }
+ | ....^`,
+		},
 	}
 
 	for _, test := range tests {