microcad-lang-parse 0.5.0

// Copyright © 2026 The µcad authors <info@microcad.xyz>
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::ast;
use crate::ast::Span;
use std::num::ParseIntError;

/// An operator for binary operators, together with a span
#[derive(Debug, PartialEq)]
pub struct BinaryOperator {
    /// The source span for the operator
    pub span: Span,
    /// The type of the operator
    pub operation: BinaryOperatorType,
}

/// The type of the operator for binary operations
#[derive(Debug, PartialEq, Clone)]
#[allow(missing_docs)]
pub enum BinaryOperatorType {
    Add,
    Subtract,
    Multiply,
    Divide,
    Union,
    Intersect,
    PowerXor,
    GreaterThan,
    LessThan,
    GreaterEqual,
    LessEqual,
    Equal,
    Near,
    NotEqual,
    And,
    Or,
    Xor,
}

impl BinaryOperatorType {
    /// Get the symbolic representation for the operator
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Add => "+",
            Self::Subtract => "-",
            Self::Multiply => "*",
            Self::Divide => "/",
            Self::Union => "|",
            Self::Intersect => "&",
            Self::PowerXor => "^",
            Self::GreaterThan => ">",
            Self::LessThan => "<",
            Self::GreaterEqual => "≥",
            Self::LessEqual => "≤",
            Self::Equal => "==",
            Self::Near => "~",
            Self::NotEqual => "!=",
            Self::And => "&",
            Self::Or => "|",
            Self::Xor => "^",
        }
    }
}

/// An operator for unary operators, together with a span
#[derive(Debug, PartialEq)]
pub struct UnaryOperator {
    /// The source span for the unary operator
    pub span: Span,
    /// The type of the unary operator
    pub operation: UnaryOperatorType,
}

/// The type of the operator for unary operations
#[derive(Debug, PartialEq, Clone)]
#[allow(missing_docs)]
pub enum UnaryOperatorType {
    Minus,
    Plus,
    Not,
}

impl UnaryOperatorType {
    /// Get the symbolic representation for the operator
    pub fn as_str(&self) -> &'static str {
        match self {
            UnaryOperatorType::Minus => "-",
            UnaryOperatorType::Plus => "+",
            UnaryOperatorType::Not => "!",
        }
    }
}

/// Any expression.
#[derive(Debug, PartialEq)]
pub enum Expression {
    /// A literal: `42mm`
    Literal(ast::Literal),
    /// Something in `()` brackets: `(42mm)`
    Bracketed(Box<Expression>, Span),
    /// A tuple: `(a = 1, b = 23)`
    Tuple(TupleExpression),
    /// A range expression: `[1..4]`
    ArrayRange(ArrayRangeExpression),
    /// A list expression: `[1, 2, 3]`
    ArrayList(ArrayListExpression),
    /// A format string: `"We have {n} items"`
    String(FormatString),
    /// A qualified name: `foo::bar::baz`
    QualifiedName(QualifiedName),
    /// A marker expression: `@input`
    Marker(ast::Identifier),
    /// A binary operation: `1 + 3`
    BinaryOperation(BinaryOperation),
    /// A unary operation: `-2`
    UnaryOperation(UnaryOperation),
    /// A body expression containing statements: `{ ... }`
    Body(ast::Body),
    /// A call: `call::me(1, 2, 3)`
    Call(Call),
    /// Accessing an element: `.foo`, `.rotate()`, `#attr`, `[1]`
    ElementAccess(ElementAccess),
    /// An if expression: `if a == b { ... } else { ... }`
    If(If),
    /// Any occurred during parsing
    Error(Span),
}

impl Expression {
    /// Get the source span for the identifier
    pub fn span(&self) -> Span {
        match self {
            Expression::Literal(ex) => ex.span.clone(),
            Expression::Bracketed(_, span) => span.clone(),
            Expression::Tuple(ex) => ex.span.clone(),
            Expression::ArrayRange(ex) => ex.span.clone(),
            Expression::ArrayList(ex) => ex.span.clone(),
            Expression::String(ex) => ex.span.clone(),
            Expression::QualifiedName(ex) => ex.span.clone(),
            Expression::Marker(ex) => ex.span.clone(),
            Expression::BinaryOperation(ex) => ex.span.clone(),
            Expression::UnaryOperation(ex) => ex.span.clone(),
            Expression::Body(ex) => ex.span.clone(),
            Expression::Call(ex) => ex.span.clone(),
            Expression::ElementAccess(ex) => ex.span.clone(),
            Expression::If(ex) => ex.span.clone(),
            Expression::Error(span) => span.clone(),
        }
    }

    /// Can this expression also be used as a statement, without extra semicolon
    pub fn is_also_statement(&self) -> bool {
        matches!(self, Expression::Body(_) | Expression::If(_))
    }
}

/// A string containing a format expression
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct FormatString {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub parts: Vec<StringPart>,
}

/// A part of a [`FormatString`]
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub enum StringPart {
    Char(StringCharacter),
    Content(ast::StringLiteral),
    Expression(StringExpression),
}

/// A single character that is part of a [`FormatString`]
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct StringCharacter {
    pub span: Span,
    pub character: char,
}

/// A format expression that is part of a [`FormatString`]
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct StringExpression {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub expression: Box<Expression>,
    pub specification: Box<StringFormatSpecification>,
}

/// The format specification for a [`StringExpression`], specifying the width and precision for number formatting
///
/// All parts of the specification are optional
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct StringFormatSpecification {
    pub span: Span,
    pub precision: Option<Result<u32, (ParseIntError, Span)>>,
    pub width: Option<Result<u32, (ParseIntError, Span)>>,
}

impl StringFormatSpecification {
    /// Check if an part of the specification is specified
    pub fn is_some(&self) -> bool {
        self.precision.is_some() || self.width.is_some()
    }
}

/// An item that is part of a tuple expression
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct TupleItem {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub name: Option<ast::Identifier>,
    pub value: Expression,
}

impl ast::Dummy for TupleItem {
    fn dummy(span: Span) -> Self {
        Self {
            span: span.clone(),
            extras: ast::ItemExtras::default(),
            name: None,
            value: Expression::Error(span),
        }
    }
}

/// A tuple expression, a fixed size set of items that don't need to be the same type
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct TupleExpression {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub values: Vec<TupleItem>,
}

/// An array range, containing all values from the start value (inclusive) till then end value (exclusive)
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct ArrayRangeExpression {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub start: Box<ArrayItem>,
    pub end: Box<ArrayItem>,
    pub unit: Option<ast::Unit>,
}

/// An array specified as a list of items
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct ArrayListExpression {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub items: Vec<ArrayItem>,
    pub unit: Option<ast::Unit>,
}

/// An item that can be part of an array expression
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct ArrayItem {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub expression: Expression,
}

/// A qualified name, containing one or more [`Identifier`]s separated by `::`
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct QualifiedName {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub parts: Vec<ast::Identifier>,
}

/// A binary operation
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct BinaryOperation {
    pub span: Span,
    pub lhs: Box<Expression>,
    pub operation: BinaryOperator,
    pub rhs: Box<Expression>,
}

/// A unary operation
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct UnaryOperation {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub operation: UnaryOperator,
    pub rhs: Box<Expression>,
}

/// A function call
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct Call {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub name: QualifiedName,
    pub arguments: ArgumentList,
}

/// An expression that access an element from another expression.
///
/// Either accessing an array or tuple item, accessing an attribute of a value or a method call.
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct ElementAccess {
    pub span: Span,
    pub value: Box<Expression>,
    pub element_chain: Vec<Element>,
}

/// The possible element access types
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub enum ElementInner {
    Attribute(ast::Identifier),
    Tuple(ast::Identifier),
    Method(Call),
    ArrayElement(Box<Expression>),
}

#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct Element {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub inner: ElementInner,
}

#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct Body {
    pub span: Span,
    pub statements: ast::StatementList,
}

/// An if expression, can be used as either a statement or expression
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct If {
    pub span: Span,
    pub if_span: Span,
    pub extras: ast::ItemExtras,
    pub condition: Box<Expression>,
    pub body: Body,
    pub next_if_span: Option<Span>,
    pub next_if: Option<Box<If>>,
    pub else_span: Option<Span>,
    pub else_body: Option<Body>,
}

/// A list of arguments to a function call
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct ArgumentList {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub arguments: Vec<Argument>,
}

impl ast::Dummy for ArgumentList {
    fn dummy(span: Span) -> Self {
        Self {
            span,
            extras: ast::ItemExtras::default(),
            arguments: Vec::new(),
        }
    }
}

/// A function argument that is part of an [`ArgumentList`]
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub enum Argument {
    Unnamed(UnnamedArgument),
    Named(NamedArgument),
}

impl Argument {
    /// The name of the argument, if specified
    pub fn name(&self) -> Option<&ast::Identifier> {
        match self {
            Argument::Unnamed(_) => None,
            Argument::Named(arg) => Some(&arg.name),
        }
    }

    /// The value of the argument
    pub fn value(&self) -> &Expression {
        match self {
            Argument::Unnamed(arg) => &arg.value,
            Argument::Named(arg) => &arg.value,
        }
    }

    /// The span of the argument
    pub fn span(&self) -> &Span {
        match self {
            Argument::Unnamed(arg) => &arg.span,
            Argument::Named(arg) => &arg.span,
        }
    }
}

/// An argument without specified name
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct UnnamedArgument {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub value: Expression,
}

/// An argument with a specified name
#[derive(Debug, PartialEq)]
#[allow(missing_docs)]
pub struct NamedArgument {
    pub span: Span,
    pub extras: ast::ItemExtras,
    pub name: ast::Identifier,
    pub value: Expression,
}