aimx/expressions/

unary.rs

//! Unary expression parsing for AIMX.
//!
//! Provides the AST and parser for unary operators (`!`, unary `+`/`-`, and
//! `(Type)` casts) with right-to-left associativity. See
//! [`parse_unary`] and [`Unary`].

use crate::{
    aim::{ContextLike, Typedef, WriterLike, Writer, parse_literal_type},
    expressions::{ExpressionLike, Postfix, Primary, parse_postfix},
    literals::Literal,
    values::Value,
};
use anyhow::{Result, anyhow};
use nom::{
    IResult, Parser,
    branch::alt,
    character::complete::{char, multispace0},
    combinator::map,
    multi::many1, sequence::delimited,
};
use std::{
    fmt,
    sync::Arc,
};

/// Unary expression node.
///
/// Flattened AST for unary operators and primary expressions.
#[derive(Debug, Clone, PartialEq)]
pub enum Unary {
    /// `!operand`
    Not(Box<Unary>),
    /// `+operand`
    Positive(Box<Unary>),
    /// `-operand`
    Negative(Box<Unary>),
    /// `(Bool)operand`
    CastBool(Box<Unary>),
    /// `(Date)operand`
    CastDate(Box<Unary>),
    /// `(Number)operand`
    CastNumber(Box<Unary>),
    /// `(Task)operand`
    CastTask(Box<Unary>),
    /// `(Text)operand`
    CastText(Box<Unary>),
    /// Primary or postfix expression.
    Primary(Box<Primary>),
}

/// Parse a cast operator `(Type)` into a [`Typedef`].
fn parse_cast_operator(input: &str) -> IResult<&str, Typedef> {
    delimited(
        char('('),
        delimited(multispace0, parse_literal_type, multispace0),
        char(')'),
    ).parse(input)
}

/// Internal unary operator used while parsing.
enum UnaryOp {
    Not,
    Positive,
    Negative,
    Cast(Typedef),
}

/// Parse a unary operator token.
fn parse_unary_operator(input: &str) -> IResult<&str, UnaryOp> {
    delimited(
        multispace0,
        alt((
            map(char('!'), |_| UnaryOp::Not),
            map(char('+'), |_| UnaryOp::Positive),
            map(char('-'), |_| UnaryOp::Negative),
            map(parse_cast_operator, |typedef| UnaryOp::Cast(typedef)),
        )),
        multispace0,
    ).parse(input)
}

impl Unary {
    /// Construct a [`Unary`] from a parsed unary operator and operand.
    fn new(op: UnaryOp, unary: Unary) -> Self {
        let boxed = Box::new(unary);
        match op {
            UnaryOp::Not => Unary::Not(boxed),
            UnaryOp::Positive => Unary::Positive(boxed),
            UnaryOp::Negative => Unary::Negative(boxed),
            UnaryOp::Cast(typedef) => match typedef {
                Typedef::Bool => Unary::CastBool(boxed),
                Typedef::Date => Unary::CastDate(boxed),
                Typedef::Number => Unary::CastNumber(boxed),
                Typedef::Task => Unary::CastTask(boxed),
                Typedef::Text => Unary::CastText(boxed),
                _ => unreachable!(),
            },
        }
    }

    pub fn print(&self, writer: &mut Writer) {
        match self {
            Unary::Not(operand) => {
                writer.write_unary_op("!", operand.as_ref());
            }
            Unary::Positive(operand) => {
                writer.write_unary_op("+", operand.as_ref());
            }
            Unary::Negative(operand) => {
                writer.write_unary_op("-", operand.as_ref());
            }
            Unary::CastBool(operand) => {
                writer.write_str("(Bool)");
                operand.print(writer);
            }
            Unary::CastDate(operand) => {
                writer.write_str("(Date)");
                operand.print(writer);
            }
            Unary::CastNumber(operand) => {
                writer.write_str("(Number)");
                operand.print(writer);
            }
            Unary::CastTask(operand) => {
                writer.write_str("(Task)");
                operand.print(writer);
            }
            Unary::CastText(operand) => {
                writer.write_str("(Text)");
                operand.print(writer);
            }
            Unary::Primary(primary) => primary.print(writer),
        }
    }
}

/// Parse a unary expression.
///
/// Supports chains of unary operators (right-to-left) applied to a postfix
/// expression. Falls back to parsing a postfix-only expression.
pub fn parse_unary(input: &str) -> IResult<&str, Unary> {
    // Chain any unary operators
    if let Ok((input, mut unary_chain)) = many1(parse_unary_operator).parse(input) {
        // Get the primary operand
        let (input, postfix) = parse_postfix(input)?;
        // Convert to unary
        let mut unary = match postfix {
            Postfix::Primary(primary) => Unary::Primary(primary),
            _ => Unary::Primary(Box::new(Primary::Postfix(postfix))),
        };
        // Iterate unary chain right to left
        while let Some(op) = unary_chain.pop() {
            unary = Unary::new(op, unary);
        }
        Ok((input, unary))
    } else {
        // Parse the primary
        let (input, postfix) = parse_postfix(input)?;
        let unary = match postfix {
            Postfix::Primary(primary) => Unary::Primary(primary),
            _ => Unary::Primary(Box::new(Primary::Postfix(postfix))),
        };
        Ok((input, unary))
    }
}

impl ExpressionLike for Unary {
    /// Evaluate the unary expression.
    fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Arc<Value>> {
        match self {
            Unary::Not(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                let found = val.type_as_string();
                match &*val.as_bool() {
                    Value::Literal(Literal::Bool(b)) => Ok(Arc::new(Value::Literal(Literal::Bool(!b)))),
                    _ => Err(anyhow!(
                        "Expected Bool, found {}~{}",
                        found,
                        self.to_formula(),
                    )),
                }
            }
            Unary::Positive(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                let found = val.type_as_string();
                let number = val.as_number()?;
                match &*number {
                    Value::Literal(Literal::Number(n)) => {
                        Ok(Arc::new(Value::Literal(Literal::Number(*n))))
                    }
                    _ => Err(anyhow!(
                        "Expected numeric operand, found {}~{}",
                        found,
                        self.to_formula(),
                    )),
                }
            }
            Unary::Negative(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                let found = val.type_as_string();
                let number = val.as_number()?;
                match &*number {
                    Value::Literal(Literal::Number(n)) => {
                        Ok(Arc::new(Value::Literal(Literal::Number(-n))))
                    }
                    _ => Err(anyhow!(
                        "Expected numeric operand, found {}~{}",
                        found,
                        self.to_formula(),
                    )),
                }
            }
            Unary::CastBool(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                Ok(val.as_bool())
            }
            Unary::CastDate(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                val.as_date()
            }
            Unary::CastNumber(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                val.as_number()
            }
            Unary::CastTask(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                val.as_task()
            }
            Unary::CastText(operand) => {
                let val = operand.evaluate(context)?;
                if val.is_error() {
                    return Ok(val);
                }
                val.as_text()
            }
            Unary::Primary(primary) => primary.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 Unary {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

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