Method parseInfixExpression

pkg/dsl/parser/parser.go:658–691

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". It takes the left operand as an argument, constructs an InfixExpression with the current operator and left operand, and parses the right operand with a

(left ast.Expression)

// expression tree.
// It returns the resulting InfixExpression and any error encountered.
func (p *Parser) parseInfixExpression(left ast.Expression) (ast.Expression, error) {
	// Ensure the current token is a valid infix operator before proceeding.
	if !p.isInfixOperator(p.currentToken.Type) {
		p.currentError(token.AND, token.OR, token.NOT) // Replace with your actual valid infix token types
		return nil, p.Error()
	}

	// Create a new InfixExpression with the left operand and the current operator.
	expression := &ast.InfixExpression{
		Op:       p.currentToken,
		Left:     left,
		Operator: ast.Operator(p.currentToken.Literal),
	}

	// Get the precedence of the current operator and consume the operator token.
	precedence := p.currentPrecedence()
	p.next()

	// Parse the right operand with a higher precedence to construct the final expression tree.
	right, err := p.parseExpression(precedence)
	if err != nil {
		return nil, err
	}

	// Ensure the right operand is not nil.
	if right == nil {
		p.currentError(token.IDENT, token.LP) // Replace with your actual valid right operand token types
		return nil, p.Error()
	}

	// Set the right operand of the InfixExpression and return it.
	expression.Right = right
	return expression, nil
}

// parseIntegerLiteral parses an integer literal and returns the resulting IntegerLiteral expression.
func (p *Parser) isInfixOperator(tokenType token.Type) bool {