Method parseExpression

pkg/dsl/parser/parser.go:600–650

parseExpression method parses an expression with a given precedence level and returns the parsed expression as an AST node. It takes an integer value indicating the precedence level.

(precedence int)

// parseExpression method parses an expression with a given precedence level and returns the parsed expression as an AST node. It takes an integer value indicating the precedence level.
func (p *Parser) parseExpression(precedence int) (ast.Expression, error) {
	var exp ast.Expression
	var err error

	if p.currentTokenIs(token.NEWLINE) && p.previousTokenIs(token.LP, token.AND, token.OR, token.NOT, token.ASSIGN) {
		p.next() // skip newline after operators
	} // Newline handling complete
	if p.currentTokenIs(token.LP) {
		p.next() // Consume the left parenthesis.
		exp, err = p.parseExpression(LOWEST)
		if err != nil {
			return nil, err
		}

		if !p.expect(token.RP) {
			return nil, p.Error()
		}
		p.next() // Consume the right parenthesis.
	} else {
		// get the prefix parsing function for the current token type
		prefix := p.prefixParseFns[p.currentToken.Type]
		if prefix == nil {
			p.noPrefixParseFnError(p.currentToken.Type)
			return nil, p.Error()
		}

		// parse the prefix expression
		exp, err = prefix()
		if err != nil {
			return nil, p.Error()
		}
	}

	// continue parsing the expression while the next token has a higher precedence level than the current precedence level
	for !p.peekTokenIs(token.NEWLINE) && precedence < p.peekPrecedence() {
		// get the infix parsing function for the next token type
		infix := p.infixParseFunc[p.peekToken.Type]
		if infix == nil {
			return exp, nil
		}
		p.next()
		// parse the infix expression with the current expression as its left-hand side
		exp, err = infix(exp)
		if err != nil {
			return nil, p.Error()
		}
	}

	// return the parsed expression and nil for the error value
	return exp, nil
}

// parseInfixExpression parses an infix expression that has a left operand and an operator followed by
// a right operand, such as "a or b" or "x and y".