Method parseUnaryExpr

query/expr/parser.go:359–473

parseUnaryExpr parses an non-binary expression. TODO: shz@ revisit inclusion parameter when open sourcing

(inclusion bool)

// parseUnaryExpr parses an non-binary expression.
// TODO: shz@ revisit inclusion parameter when open sourcing
func (p *Parser) parseUnaryExpr(inclusion bool) (Expr, error) {
	// If the first token is a LPAREN then parse it as its own grouped expression.
	if tok, _, _ := p.scanIgnoreWhitespace(); tok == LPAREN {
		expr, err := p.ParseExpr(0)
		if err != nil {
			return nil, err
		}
		tok, pos, lit := p.scanIgnoreWhitespace()
		if tok == RPAREN {
			// Expect an RPAREN at the end.
			if inclusion {
				return &Call{Args: []Expr{expr}}, nil
			}
			return &ParenExpr{Expr: expr}, nil
		} else if tok == COMMA {
			// Parse a tuple as a function call with empty name.
			var args []Expr
			args = append(args, expr)

			for {
				// Parse an expression argument.
				arg, err := p.ParseExpr(0)
				if err != nil {
					return nil, err
				}
				args = append(args, arg)

				// If there's not a comma next then stop parsing arguments.
				if tok, _, _ := p.scan(); tok != COMMA {
					p.unscan()
					break
				}
			}

			// There should be a right parentheses at the end.
			if tok, pos, lit := p.scan(); tok != RPAREN {
				return nil, newParseError(tokstr(tok, lit), []string{")"}, pos)
			}

			return &Call{Args: args}, nil
		} else {
			return nil, newParseError(tokstr(tok, lit), []string{")"}, pos)
		}

	}
	p.unscan()

	// Read next token.
	tok, pos, lit := p.scanIgnoreWhitespace()
	if tok.isUnaryOperator() {
		expr, err := p.ParseExpr(tok.Precedence())
		if err != nil {
			return nil, err
		}
		return &UnaryExpr{Op: tok, Expr: expr}, nil
	}

	switch tok {