Add # operator support

Author: antonmedv

parser/lexer/lexer_test.go

@@ -47,7 +47,7 @@ var lexTests = []lexTest{
 		},
 	},
 	{
-		"a and orb().val",
+		"a and orb().val #.",
 		[]Token{
 			{Kind: Identifier, Value: "a"},
 			{Kind: Operator, Value: "and"},
@@ -56,6 +56,8 @@ var lexTests = []lexTest{
 			{Kind: Bracket, Value: ")"},
 			{Kind: Operator, Value: "."},
 			{Kind: Identifier, Value: "val"},
+			{Kind: Operator, Value: "#"},
+			{Kind: Operator, Value: "."},
 			{Kind: EOF},
 		},
 	},

parser/lexer/state.go

@@ -28,9 +28,11 @@ func root(l *lexer) stateFn {
 		l.emit(Bracket)
 	case strings.ContainsRune(")]}", r):
 		l.emit(Bracket)
-	case strings.ContainsRune(",?!:%#&*+-/<=>^|", r):
+	case strings.ContainsRune(",?!:%&*+-/<=>^|", r):
 		l.backup()
 		return operator
+	case r == '#':
+		l.emit(Operator)
 	case r == '.':
 		l.backup()
 		return dot

parser/parser.go

@@ -25,6 +25,10 @@ type operator struct {
 	associativity associativity
 }
 
+type builtin struct {
+	arity int
+}
+
 var unaryOperators = map[string]operator{
 	"not": {50, left},
 	"!":   {50, left},
@@ -58,14 +62,14 @@ var binaryOperators = map[string]operator{
 	"**":         {70, right},
 }
 
-var builtins = map[string]bool{
-	"len":    true,
-	"all":    true,
-	"none":   true,
-	"any":    true,
-	"one":    true,
-	"filter": true,
-	"map":    true,
+var builtins = map[string]builtin{
+	"len":    {1},
+	"all":    {2},
+	"none":   {2},
+	"any":    {2},
+	"one":    {2},
+	"filter": {2},
+	"map":    {2},
 }
 
 type parser struct {
@@ -95,7 +99,7 @@ func Parse(input string) (*Tree, error) {
 
 	node := p.parseExpression(0)
 
-	if !p.isEOF() {
+	if !p.current.Is(EOF) {
 		p.error("unexpected token %v", p.current)
 	}
 
@@ -121,7 +125,8 @@ func (p *parser) error(format string, args ...interface{}) {
 func (p *parser) next() {
 	p.pos++
 	if p.pos >= len(p.tokens) {
-		panic("unexpected end of expression")
+		p.error("unexpected end of expression")
+		return
 	}
 	p.current = p.tokens[p.pos]
 }
@@ -134,10 +139,6 @@ func (p *parser) expect(kind Kind, values ...string) {
 	p.error("unexpected token %v", p.current)
 }
 
-func (p *parser) isEOF() bool {
-	return p.current.Is(EOF)
-}
-
 // parse functions
 
 func (p *parser) parseExpression(precedence int) Node {
@@ -216,6 +217,17 @@ func (p *parser) parsePrimary() Node {
 		return p.parsePostfixExpression(expr)
 	}
 
+	if token.Is(Operator, "#") {
+		p.next()
+		node := &PointerNode{Base: Loc(token.Location)}
+		return p.parsePostfixExpression(node)
+	}
+
+	if token.Is(Operator, ".") {
+		node := &PointerNode{Base: Loc(token.Location)}
+		return p.parsePostfixExpression(node)
+	}
+
 	return p.parsePrimaryExpression()
 }
 
@@ -305,18 +317,54 @@ func (p *parser) parsePrimaryExpression() Node {
 func (p *parser) parseIdentifierExpression(token Token) Node {
 	var node Node
 	if p.current.Is(Bracket, "(") {
-		arguments := p.parseArguments()
-		if _, ok := builtins[token.Value]; ok {
-			node = &BuiltinNode{Base: Loc(token.Location), Name: token.Value, Arguments: arguments}
+		var arguments []Node
+
+		if b, ok := builtins[token.Value]; ok {
+			p.expect(Bracket, "(")
+			// TODO: Add builtins signatures.
+			if b.arity == 1 {
+				arguments = make([]Node, 1)
+				arguments[0] = p.parseExpression(0)
+			} else if b.arity == 2 {
+				arguments = make([]Node, 2)
+				arguments[0] = p.parseExpression(0)
+				p.expect(Operator, ",")
+				arguments[1] = p.parseClosure()
+			}
+			p.expect(Bracket, ")")
+
+			node = &BuiltinNode{
+				Base:      Loc(token.Location),
+				Name:      token.Value,
+				Arguments: arguments,
+			}
 		} else {
-			node = &FunctionNode{Base: Loc(token.Location), Name: token.Value, Arguments: arguments}
+			arguments = p.parseArguments()
+			node = &FunctionNode{
+				Base:      Loc(token.Location),
+				Name:      token.Value,
+				Arguments: arguments,
+			}
 		}
 	} else {
 		node = &IdentifierNode{Base: Loc(token.Location), Value: token.Value}
 	}
 	return node
 }
 
+func (p *parser) parseClosure() Node {
+	token := p.current
+	p.expect(Bracket, "{")
+
+	node := p.parseExpression(0)
+
+	p.expect(Bracket, "}")
+	return &ClosureNode{
+		Base: Loc(token.Location),
+		Node: node,
+	}
+}
+
 func (p *parser) parseArrayExpression(token Token) Node {
 	nodes := p.parseList("[", "]")
 	return &ArrayNode{Base: Loc(token.Location), Nodes: nodes}
@@ -403,10 +451,22 @@ func (p *parser) parsePostfixExpression(node Node) Node {
 		} else if token.Value == "[" {
 			p.next()
 			arg := p.parseExpression(0)
-			node = &IndexNode{
-				Base:  Loc(token.Location),
-				Node:  node,
-				Index: arg,
+			if p.current.Is(Operator, ":") {
+				p.next()
+				from := arg
+				to := p.parseExpression(0)
+				node = &SliceNode{
+					Base: Loc(p.current.Location),
+					Node: node,
+					From: from,
+					To:   to,
+				}
+			} else {
+				node = &IndexNode{
+					Base:  Loc(token.Location),
+					Node:  node,
+					Index: arg,
+				}
 			}
 			p.expect(Bracket, "]")
 		} else {

parser/parser_test.go

@@ -186,6 +186,14 @@ func TestParse(t *testing.T) {
 			"all(Tickets, {.Price > 0})",
 			&ast.BuiltinNode{Name: "all", Arguments: []ast.Node{&ast.IdentifierNode{Value: "Tickets"}, &ast.ClosureNode{Node: &ast.BinaryNode{Operator: ">", Left: &ast.PropertyNode{Node: &ast.PointerNode{}, Property: "Price"}, Right: &ast.IntegerNode{Value: 0}}}}},
 		},
+		{
+			"one(Tickets, {#.Price > 0})",
+			&ast.BuiltinNode{Name: "one", Arguments: []ast.Node{&ast.IdentifierNode{Value: "Tickets"}, &ast.ClosureNode{Node: &ast.BinaryNode{Operator: ">", Left: &ast.PropertyNode{Node: &ast.PointerNode{}, Property: "Price"}, Right: &ast.IntegerNode{Value: 0}}}}},
+		},
+		{
+			"filter(Prices, {# > 100})",
+			&ast.BuiltinNode{Name: "filter", Arguments: []ast.Node{&ast.IdentifierNode{Value: "Prices"}, &ast.ClosureNode{Node: &ast.BinaryNode{Operator: ">", Left: &ast.PointerNode{}, Right: &ast.IntegerNode{Value: 100}}}}},
+		},
 		{
 			"array[1:2]",
 			&ast.SliceNode{Node: &ast.IdentifierNode{Value: "array"}, From: &ast.IntegerNode{Value: 1}, To: &ast.IntegerNode{Value: 2}},