aimx/expressions/

primary.rs

//! Primary expression parsing for AIMX.
//!
//! Provides parsing and evaluation for primary expressions: literals, references,
//! collections, parentheses, and flattened higher-precedence operators.
//! Used internally by the expression parser and evaluator.

use crate::{
    aim::{ContextLike, WriterLike, Writer},
    expressions::{
        Additive, Closure, Coalesce, Collection, Conditional, Equality, Expression, ExpressionLike,
        LogicalAnd, LogicalOr, Multiplicative, Postfix, Reference, Relational, Unary,
        parse_collection, parse_expression, parse_reference,
    },
    literals::{Literal, parse_literal},
    values::Value,
};
use anyhow::Result;
use nom::{
    IResult, Parser,
    branch::alt,
    character::complete::{char, multispace0},
    combinator::map, sequence::delimited,
};
use std::{
    fmt,
    sync::Arc,
};

/// Primary expression node.
///
/// Wraps literals, references, parentheses, collections, and flattened
/// higher-precedence operators for unified parsing and evaluation.
/// `Postfix` through `Closure` variants are populated by the parser to keep
/// the AST shallow and evaluation efficient.
#[derive(Debug, Clone, PartialEq)]
pub enum Primary {
    /// A literal value such as a number, text string, boolean, date, or task
    Literal(Literal),
    /// A workflow rule reference
    Reference(Arc<Reference>),
    /// A parenthesized expression
    Parentheses(Expression),
    // A Collection expression
    Collection(Collection),

    // Flattened abstract syntax tree
    Postfix(Postfix),
    Unary(Unary),
    Multiplicative(Multiplicative),
    Additive(Additive),
    Relational(Relational),
    Equality(Equality),
    LogicalAnd(LogicalAnd),
    LogicalOr(LogicalOr),
    Coalesce(Coalesce),
    Conditional(Conditional),
    Closure(Closure),
}

impl Primary {
    /// Returns `true` if this `Primary` is [`Primary::Literal`].
    pub fn is_literal(&self) -> bool {
        match self {
            Primary::Literal(_) => true,
            _ => false,
        }
    }

    /// Returns `true` if this `Primary` is [`Primary::Reference`].
    pub fn is_reference(&self) -> bool {
        match self {
            Primary::Reference(_) => true,
            _ => false,
        }
    }

    /// Write this primary expression to a [`Writer`].
    pub fn print(&self, writer: &mut Writer) {
        match self {
            Primary::Literal(literal) => literal.print(writer),
            Primary::Reference(reference) => reference.print(writer),
            Primary::Parentheses(expression) => {
                writer.write_char('(');
                expression.print(writer);
                writer.write_char(')');
            }
            Primary::Collection(collection) => collection.print(writer),

            Primary::Postfix(postfix) => postfix.print(writer),
            Primary::Unary(unary) => unary.print(writer),
            Primary::Multiplicative(multiplicative) => multiplicative.print(writer),
            Primary::Additive(additive) => additive.print(writer),
            Primary::Relational(relational) => relational.print(writer),
            Primary::Equality(equality) => equality.print(writer),
            Primary::LogicalAnd(logical_and) => logical_and.print(writer),
            Primary::LogicalOr(logical_or) => logical_or.print(writer),
            Primary::Coalesce(coalesce) => coalesce.print(writer),
            Primary::Conditional(conditional) => conditional.print(writer),
            Primary::Closure(closure) => closure.print(writer),
        }
    }
}

/// Parse a primary expression.
///
/// Recognizes literals, references, collections, and parenthesized expressions,
/// and emits a [`Primary`] node. Used internally by the expression parser.
///
/// # Grammar
///
/// The primary expression grammar follows:
/// ```text
/// primary = literal | reference | '(' expression ')'
/// ```
///
/// Where:
/// - `literal` represents any valid literal value (number, text, boolean, date, task)
/// - `reference` represents a variable or field reference
/// - `expression` represents any valid AIMX expression
pub fn parse_primary(input: &str) -> IResult<&str, Primary> {
    alt((
        map(parse_literal, Primary::Literal),
        map(parse_reference, Primary::Reference),
        map(parse_collection, |collection| {
            Primary::Collection(collection)
        }),
        map(parse_parentheses, |expression| {
            Primary::Parentheses(expression)
        }),
    ))
    .parse(input)
}

/// Parse a parenthesized expression.
///
/// Accepts `()` as [`Expression::Empty`] and otherwise parses an inner expression
/// between `(` and `)` with optional surrounding whitespace.
pub fn parse_parentheses(input: &str) -> IResult<&str, Expression> {
    alt((
        // Empty parentheses case
        (
            char('('),
            multispace0,
            char(')'),
        ).map(|_| Expression::Empty),
        
        // Non-empty parentheses case
        delimited(
            char('('),
            delimited(multispace0, parse_expression, multispace0),
            char(')'),
        ),
    )).parse(input)
}

impl ExpressionLike for Primary {
    /// Evaluate this primary expression in the given context.
    fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Arc<Value>> {
        match self {
            Primary::Literal(literal) => {
                if literal.is_empty() {
                    Ok(Value::empty())
                } else {
                    Ok(Arc::new(Value::Literal(literal.clone())))
                }
            }
            Primary::Reference(reference) => reference.evaluate(context),
            Primary::Parentheses(expression) => expression.evaluate(context),
            Primary::Collection(collection) => collection.evaluate(context),

            Primary::Postfix(postfix) => postfix.evaluate(context),
            Primary::Unary(unary) => unary.evaluate(context),
            Primary::Multiplicative(multiplicative) => multiplicative.evaluate(context),
            Primary::Additive(additive) => additive.evaluate(context),
            Primary::Relational(relational) => relational.evaluate(context),
            Primary::Equality(equality) => equality.evaluate(context),
            Primary::LogicalAnd(logical_and) => logical_and.evaluate(context),
            Primary::LogicalOr(logical_or) => logical_or.evaluate(context),
            Primary::Coalesce(coalesce) => coalesce.evaluate(context),
            Primary::Conditional(conditional) => conditional.evaluate(context),
            Primary::Closure(closure) => closure.evaluate(context),
        }
    }

    /// Return the formula-string representation (round-trippable by the parser).
    fn to_formula(&self) -> String {
        let mut writer = Writer::formulizer();
        self.print(&mut writer);
        writer.finish()
    }
}

impl WriterLike for Primary {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

impl fmt::Display for Primary {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_stringized())
    }
}