geo_aid_script/

parser.rs

//! Parses `GeoScript`'s tokens into a structured representation. Most of this module's
//! functionality is autogenerated through macros.

use geo_aid_derive::Parse;
use num_traits::Zero;

use crate::token::number::ProcNum;
use crate::unroll::library;
use std::fmt::Formatter;
use std::ops::Deref;
use std::{
    fmt::{Debug, Display},
    iter::Peekable,
    marker::PhantomData,
};

use crate::span;

use super::{
    token::{
        number::CompExponent, Ampersant, Asterisk, At, Caret, Colon, Comma, Dollar, Dot, Eq,
        Exclamation, Gt, Gteq, Ident, LBrace, LParen, LSquare, Let, Lt, Lteq, Minus, NamedIdent,
        NumberLit, Plus, Question, RBrace, RParen, RSquare, Semi, Slash, Span, StrLit, TokInteger,
        Token,
    },
    unit, ComplexUnit, Error,
};

/// The main trait for parsing tokens.
pub trait Parse {
    /// The first token of a structure.
    type FirstToken: CheckParses;

    /// Parse the tokens into `Self`.
    ///
    /// # Errors
    /// Returns an error if parsing was unsuccessful.
    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized;

    /// Get the span of this node.
    fn get_span(&self) -> Span;
}

/// Check if `Self` would parse given the tokens.
pub trait CheckParses {
    /// Check if `Self` would parse given the tokens.
    fn check_parses<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &InputStream<'t, I>,
    ) -> Option<bool>;
}

impl<T: Parse> CheckParses for T {
    fn check_parses<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &InputStream<'t, I>,
    ) -> Option<bool> {
        Some(input.clone().parse::<Self>().is_ok())
    }
}

/// A simple token alternative for use with `FirstToken`
#[derive(Debug)]
pub struct TokenOr<T, U> {
    phantom_t: PhantomData<T>,
    phantom_u: PhantomData<U>,
}

impl<T: CheckParses, U: CheckParses> CheckParses for TokenOr<T, U> {
    fn check_parses<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &InputStream<'t, I>,
    ) -> Option<bool> {
        T::check_parses(input).or_else(|| U::check_parses(input))
    }
}

/// A simple token option for use with `FirstToken`
#[derive(Debug)]
pub struct Maybe<T> {
    phantom_t: PhantomData<T>,
}

impl<T: CheckParses> CheckParses for Maybe<T> {
    fn check_parses<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &InputStream<'t, I>,
    ) -> Option<bool> {
        T::check_parses(input).and_then(|x| if x { Some(x) } else { None })
    }
}

impl<T: Parse> Parse for Vec<T> {
    type FirstToken = Maybe<T::FirstToken>;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let mut parsed = Self::new();

        while let Ok(Some(v)) = input.parse() {
            parsed.push(v);
        }

        Ok(parsed)
    }

    fn get_span(&self) -> Span {
        self.first().map_or(Span::empty(), |x| {
            x.get_span().join(self.last().unwrap().get_span())
        })
    }
}

/// Vector with at least one element.
pub struct AtLeastOne<T>(Vec<T>);

impl<T: Debug> Debug for AtLeastOne<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}", self.0)
    }
}

impl<T> Deref for AtLeastOne<T> {
    type Target = Vec<T>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T: Parse> Parse for AtLeastOne<T> {
    type FirstToken = T::FirstToken;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let mut parsed = Vec::new();

        // First element is forced.
        if let Ok(v) = input.parse() {
            parsed.push(v);
        }

        while let Ok(Some(v)) = input.parse() {
            parsed.push(v);
        }

        Ok(Self(parsed))
    }

    fn get_span(&self) -> Span {
        self.first().map_or(Span::empty(), |x| {
            x.get_span().join(self.last().unwrap().get_span())
        })
    }
}

impl<T: Parse, U: Parse> Parse for (T, U) {
    type FirstToken = T::FirstToken;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        Ok((input.parse()?, input.parse()?))
    }

    fn get_span(&self) -> Span {
        self.0.get_span().join(self.1.get_span())
    }
}

impl<T: Parse> Parse for Option<T> {
    type FirstToken = Maybe<T::FirstToken>;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let mut branch = input.clone();

        if let Ok(v) = branch.parse() {
            *input = branch;
            Ok(Some(v))
        } else {
            Ok(None)
        }
    }

    fn get_span(&self) -> Span {
        match self {
            Some(v) => v.get_span(),
            None => span!(0, 0, 0, 0),
        }
    }
}

/// The stream (peekable iterator) of input tokens
#[derive(Debug, Clone)]
pub struct InputStream<'t, I: Iterator<Item = &'t Token> + Clone> {
    /// The underlying iterator.
    it: Peekable<I>,
}

impl<'t, I: Iterator<Item = &'t Token> + Clone> InputStream<'t, I> {
    /// Create a new stream from an iterator over tokens.
    #[must_use]
    pub fn new<It: IntoIterator<IntoIter = I>>(it: It) -> Self {
        Self {
            it: it.into_iter().peekable(),
        }
    }

    /// Parse tokens as a node.
    ///
    /// # Errors
    /// Returns an error if failed to parse
    pub fn parse<P: Parse>(&mut self) -> Result<P, Error> {
        P::parse(self)
    }

    /// Get the next token
    ///
    /// # Errors
    /// Returns an EOF error if there is no next token.
    pub fn get_token(&mut self) -> Result<&'t Token, Error> {
        self.it.next().ok_or(Error::EndOfInput)
    }

    /// Expect there to be a token. Does not advance the stream.
    ///
    /// # Errors
    /// Returns an EOF error if there is no next token.
    pub fn expect_token(&mut self) -> Result<(), Error> {
        if self.eof() {
            Err(Error::EndOfInput)
        } else {
            Ok(())
        }
    }

    /// Check if this is the end of input.
    #[must_use]
    pub fn eof(&mut self) -> bool {
        self.it.peek().is_none()
    }
}

/// A binary operator, like `+`, `-`, `*` or `/`.
#[derive(Debug, Parse)]
pub enum BinaryOperator {
    /// Addition
    Add(Plus),
    /// Subtraction
    Sub(Minus),
    /// Multiplication
    Mul(Asterisk),
    /// Division
    Div(Slash),
}

impl Display for BinaryOperator {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            BinaryOperator::Add(_) => write!(f, "+"),
            BinaryOperator::Sub(_) => write!(f, "-"),
            BinaryOperator::Mul(_) => write!(f, "*"),
            BinaryOperator::Div(_) => write!(f, "/"),
        }
    }
}

/// `&(point, ...)` - a point collection constructor allowing the creation of
/// of a point collection from individual point expressions.
#[derive(Debug, Parse)]
#[parse(first_token = Ampersant)]
pub struct PointCollectionConstructor {
    pub ampersant: Ampersant,
    pub left_paren: LParen,
    pub points: Punctuated<Expression<false>, Comma>,
    pub right_paren: RParen,
}

/// Punctuated expressions.
#[derive(Debug)]
pub struct ImplicitIterator<const ITER: bool> {
    pub exprs: Punctuated<SimpleExpression, Comma>,
}

impl<const ITER: bool> ImplicitIterator<ITER> {
    /// Get the expression at given index.
    #[must_use]
    pub fn get(&self, index: usize) -> Option<&SimpleExpression> {
        if ITER {
            self.exprs.get(index)
        } else {
            Some(&self.exprs.first)
        }
    }
}

impl<const ITER: bool> Parse for ImplicitIterator<ITER> {
    type FirstToken = <SimpleExpression as Parse>::FirstToken;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        if ITER {
            Ok(Self {
                exprs: input.parse()?,
            })
        } else {
            Ok(Self {
                exprs: Punctuated {
                    first: input.parse()?,
                    collection: Vec::new(),
                },
            })
        }
    }

    fn get_span(&self) -> Span {
        self.exprs.get_span()
    }
}

/// `$id(a, b, ...)` - an explicit iterator with an id.
#[derive(Debug)]
pub struct ExplicitIterator {
    pub dollar: Dollar,
    pub id_token: TokInteger,
    pub id: u8,
    pub left_paren: LParen,
    pub exprs: Punctuated<Expression<false>, Comma>,
    pub right_paren: RParen,
}

impl ExplicitIterator {
    /// Get the expression at given index.
    #[must_use]
    pub fn get(&self, index: usize) -> Option<&Expression<false>> {
        self.exprs.get(index)
    }
}

impl Parse for ExplicitIterator {
    type FirstToken = Dollar;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        let mut parsed = Self {
            dollar: input.parse()?,
            id_token: input.parse()?,
            id: 0,
            left_paren: input.parse()?,
            exprs: input.parse()?,
            right_paren: input.parse()?,
        };

        parsed.id = parsed
            .id_token
            .parsed
            .parse()
            .map_err(|_| Error::NumberTooLarge {
                error_span: parsed.id_token.get_span(),
            })?;

        if parsed.exprs.len() == 1 {
            return Err(Error::SingleVariantExplicitIterator {
                error_span: parsed.dollar.span.join(parsed.right_paren.span),
            });
        }

        Ok(parsed)
    }

    fn get_span(&self) -> Span {
        self.dollar.span.join(self.right_paren.span)
    }
}

/// A parsed expression. Either an implicit iterator or a binary operation.
#[derive(Debug)]
pub enum Expression<const ITER: bool> {
    /// Simple values separated by a comma.
    ImplicitIterator(ImplicitIterator<ITER>),
    /// A binary operator expression.
    Binop(ExprBinop<ITER>),
}

impl<const ITER: bool> Parse for Expression<ITER> {
    type FirstToken = <SimpleExpression as Parse>::FirstToken;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        let mut expr = Expression::ImplicitIterator(input.parse()?);

        while let Ok(Some(op)) = input.parse() {
            let rhs = Expression::ImplicitIterator(input.parse()?);

            expr = dispatch_order(expr, op, rhs);
        }

        Ok(expr)
    }

    fn get_span(&self) -> Span {
        match self {
            Expression::ImplicitIterator(it) => it.get_span(),
            Expression::Binop(e) => e.lhs.get_span().join(e.rhs.get_span()),
        }
    }
}

/// A rational exponent of form `(a/b)`, where `a` and `b` are integer tokens.
#[derive(Debug)]
pub struct RationalExponent {
    pub lparen: LParen,
    pub num: TokInteger,
    pub slash: Slash,
    pub denum: TokInteger,
    pub rparen: RParen,
}

impl Parse for RationalExponent {
    type FirstToken = LParen;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        let parsed = Self {
            lparen: input.parse()?,
            num: input.parse()?,
            slash: input.parse()?,
            denum: input.parse()?,
            rparen: input.parse()?,
        };

        if parsed.denum.parsed.is_zero() {
            return Err(Error::ZeroDenominator {
                error_span: parsed.denum.span,
            });
        }

        Ok(parsed)
    }

    fn get_span(&self) -> Span {
        self.lparen.span.join(self.rparen.span)
    }
}

/// An integer or a ratio. Used for exponents in exponentiation.
#[derive(Debug, Parse)]
pub enum Exponent {
    Simple(TokInteger),
    Parenthesized(RationalExponent),
}

impl Exponent {
    /// Converts this exponent into a rational number.
    ///
    /// # Errors
    /// Returns an error if the numbers can't fit.
    pub fn as_comp(&self) -> Result<CompExponent, Error> {
        match self {
            Self::Simple(i) => Ok(CompExponent::new(
                i.parsed
                    .parse()
                    .map_err(|_| Error::NumberTooLarge { error_span: i.span })?,
                1,
            )),
            Self::Parenthesized(exp) => Ok(CompExponent::new(
                exp.num.parsed.parse().map_err(|_| Error::NumberTooLarge {
                    error_span: exp.num.span,
                })?,
                exp.denum
                    .parsed
                    .parse()
                    .map_err(|_| Error::NumberTooLarge {
                        error_span: exp.denum.span,
                    })?,
            )),
        }
    }
}

/// A value being raised to a rational power `v^exp`.
#[derive(Debug, Parse)]
pub struct Exponentiation {
    /// Caret token
    pub caret: Caret,
    /// Possible negation of the exponent
    pub minus: Option<Minus>,
    /// The exponent.
    pub exponent: Exponent,
}

/// A field access on a value `value.field`
#[derive(Debug, Parse)]
pub struct FieldIndex {
    /// The indexed thing
    pub name: Box<Name>,
    /// The dot
    pub dot: Dot,
    /// The field
    pub field: Ident,
}

/// A name (field, method or variable).
#[derive(Debug)]
pub enum Name {
    // Variant order matters, as it defines the parsing priority
    /// A function call.
    Call(ExprCall),
    FieldIndex(FieldIndex),
    Ident(Ident),
    Expression(ExprParenthesised),
}

impl Parse for Name {
    type FirstToken = TokenOr<Maybe<Ident>, LParen>;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let mut name = if let Some(expr) = input.parse()? {
            Self::Expression(expr)
        } else {
            Self::Ident(input.parse()?)
        };

        loop {
            name = if let Some(dot) = input.parse::<Option<Dot>>()? {
                Self::FieldIndex(FieldIndex {
                    name: Box::new(name),
                    dot,
                    field: input.parse()?,
                })
            } else if let Some(lparen) = input.parse::<Option<LParen>>()? {
                Self::Call(ExprCall {
                    name: Box::new(name),
                    lparen,
                    params: input.parse()?,
                    rparen: input.parse()?,
                })
            } else {
                break Ok(name);
            };
        }
    }

    fn get_span(&self) -> Span {
        match self {
            Self::Call(v) => v.get_span(),
            Self::FieldIndex(v) => v.get_span(),
            Self::Expression(v) => v.get_span(),
            Self::Ident(v) => v.get_span(),
        }
    }
}

/// A parsed simple expression.
#[derive(Debug, Parse)]
pub struct SimpleExpression {
    /// Possible minus for negation.
    pub minus: Option<Minus>,
    /// The kind of the expression.
    pub kind: SimpleExpressionKind,
    /// Possible exponentiation.
    pub exponent: Option<Exponentiation>,
    /// The additional display information.
    pub display: Option<DisplayProperties>,
}

/// A parsed simple expression.
#[derive(Debug, Parse)]
pub enum SimpleExpressionKind {
    /// A named (variable, field or function call)
    Name(Name),
    /// A raw number
    Number(NumberLit),
    /// An explicit iterator.
    ExplicitIterator(ExplicitIterator),
    /// A point collection construction
    PointCollection(PointCollectionConstructor),
}

/// A parsed function call
#[derive(Debug, Parse)]
pub struct ExprCall {
    /// The called thing.
    pub name: Box<Name>,
    /// The `(` token.
    pub lparen: LParen,
    /// Punctuated params. `None` if no params are given.
    pub params: Option<Punctuated<Expression<false>, Comma>>,
    /// The `)` token.
    pub rparen: RParen,
}

/// A parsed parenthesised expression
#[derive(Debug, Parse)]
pub struct ExprParenthesised {
    /// The `(` token.
    pub lparen: LParen,
    /// The contained `Expression`.
    pub content: Box<Expression<true>>,
    /// The `)` token.
    pub rparen: RParen,
}

/// A parsed binary operator expression.
#[derive(Debug, Parse)]
pub struct ExprBinop<const ITER: bool> {
    /// Left hand side
    pub lhs: Box<Expression<ITER>>,
    /// The operator
    pub operator: BinaryOperator,
    /// Right hand side.
    pub rhs: Box<Expression<ITER>>,
}

impl BinaryOperator {
    fn index(&self) -> u8 {
        match self {
            BinaryOperator::Add(_) | BinaryOperator::Sub(_) => 1,
            BinaryOperator::Mul(_) | BinaryOperator::Div(_) => 2,
        }
    }
}

/// Inserts an operator with an rhs into an operator series, considering the order of operations.
fn dispatch_order<const ITER: bool>(
    lhs: Expression<ITER>,
    op: BinaryOperator,
    rhs: Expression<ITER>, // We have to trust, that it is a valid expression.
) -> Expression<ITER> {
    match lhs {
        // if lhs is simple, there is no order to consider.
        lhs @ Expression::ImplicitIterator(_) => Expression::Binop(ExprBinop {
            lhs: Box::new(lhs),
            operator: op,
            rhs: Box::new(rhs),
        }),
        // Otherwise we compare indices of the operators and act accordingly.
        Expression::Binop(lhs) => {
            if op.index() > lhs.operator.index() {
                Expression::Binop(ExprBinop {
                    lhs: lhs.lhs,
                    operator: lhs.operator,
                    rhs: Box::new(dispatch_order(*lhs.rhs, op, rhs)),
                })
            } else {
                Expression::Binop(ExprBinop {
                    lhs: Box::new(Expression::Binop(lhs)),
                    operator: op,
                    rhs: Box::new(rhs),
                })
            }
        }
    }
}

/// A builtin rule operator
#[derive(Debug, Parse)]
pub enum PredefinedRuleOperator {
    /// Equality
    Eq(Eq),
    /// Less than
    Lt(Lt),
    /// Greater than
    Gt(Gt),
    /// Less than or equal
    Lteq(Lteq),
    /// Greater than or equal
    Gteq(Gteq),
}

/// A rule operator.
#[derive(Debug, Parse)]
pub enum RuleOperator {
    /// An inverted rule operator (!op)
    Inverted(InvertedRuleOperator),
    Predefined(PredefinedRuleOperator),
    Defined(NamedIdent),
}

/// An inverted rule operator.
#[derive(Debug, Parse)]
#[parse(first_token = Exclamation)]
pub struct InvertedRuleOperator {
    /// The `!` token
    pub exclamation: Exclamation,
    /// The operator.
    pub operator: Box<RuleOperator>,
}

/// Defines the first half of a flag statement.
#[derive(Debug, Parse)]
pub struct FlagName {
    pub at: At,
    pub name: Punctuated<NamedIdent, Dot>,
    pub colon: Colon,
}

/// A set of flags.
#[derive(Debug, Parse)]
#[parse(first_token = LBrace)]
pub struct FlagSet {
    pub lbrace: LBrace,
    pub flags: Vec<FlagStatement>,
    pub rbrace: RBrace,
}

/// Defines the second half of a flag statement.
#[derive(Debug, Parse)]
pub enum FlagValue {
    Ident(NamedIdent),
    Set(FlagSet),
    Number(NumberLit),
}

/// Defines a compiler flag or flagset.
#[derive(Debug, Parse)]
pub struct FlagStatement {
    pub name: FlagName,
    pub value: FlagValue,
}

/// A single variable definition. Contains its name and optional display properties
#[derive(Debug, Clone, Parse)]
pub struct VariableDefinition {
    /// Name of the variable.
    pub name: Ident,
    /// Display properties.
    pub display_properties: Option<DisplayProperties>,
}

/// `let <something> = <something else>`.
/// Defines variables and possibly adds rules to them.
#[derive(Debug, Parse)]
pub struct LetStatement {
    /// The `let` token.
    pub let_token: Let,
    /// The lhs ident iterator.
    pub ident: Punctuated<VariableDefinition, Comma>,
    /// The `=` token.
    pub eq: Eq,
    /// The rhs expression.
    pub expr: Expression<true>,
    /// The rule after the rhs expression.
    pub rule: Option<(RuleOperator, Expression<true>)>,
    /// The ending semicolon.
    pub semi: Semi,
}

/// `lhs ruleop rhs`.
/// Defines a rule.
#[derive(Debug, Parse)]
pub struct RuleStatement {
    /// Left hand side
    pub first: Expression<true>,
    /// The rules themselves.
    pub rules: AtLeastOne<(RuleOperator, Expression<true>)>,
    /// The ending semicolon.
    pub semi: Semi,
}

/// `?expr`. Used for displaying and biases.
#[derive(Debug, Parse)]
pub struct RefStatement {
    /// The starting question mark.
    pub question: Question,
    /// Operand.
    pub operand: Expression<true>,
    /// The ending semicolon.
    pub semi: Semi,
}

/// A general statement. A rule, `let` or a ref
#[derive(Debug)]
pub enum Statement {
    /// No operation
    Noop(Semi),
    /// let
    Let(Displayed<LetStatement>),
    /// Flag
    Flag(FlagStatement),
    /// Reference
    Ref(Displayed<RefStatement>),
    /// rule
    Rule(Displayed<RuleStatement>),
}

impl Parse for Statement {
    type FirstToken = TokenOr<
        LSquare,
        TokenOr<
            Semi,
            TokenOr<At, TokenOr<Question, TokenOr<Let, <SimpleExpression as Parse>::FirstToken>>>,
        >,
    >;

    fn parse<'t, I: Iterator<Item = &'t Token> + Clone>(
        input: &mut InputStream<'t, I>,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        let props = input.parse()?;
        input.expect_token()?;

        let tok = input.it.peek().cloned().unwrap();

        match tok {
            Token::Let(_) => Ok(Self::Let(Displayed {
                properties: props,
                statement: input.parse()?,
            })),
            Token::Semi(_) => {
                if props.is_some() {
                    Err(Error::UnexpectedProperties {
                        error_span: props.get_span(),
                    })
                } else {
                    Ok(Self::Noop(input.parse()?))
                }
            }
            Token::At(_) => {
                if props.is_some() {
                    Err(Error::UnexpectedProperties {
                        error_span: props.get_span(),
                    })
                } else {
                    Ok(Self::Flag(input.parse()?))
                }
            }
            Token::Question(_) => Ok(Self::Ref(Displayed {
                properties: props,
                statement: input.parse()?,
            })),
            _ => Ok(Self::Rule(Displayed {
                properties: props,
                statement: input.parse()?,
            })),
        }
    }

    fn get_span(&self) -> Span {
        todo!()
    }
}

impl Statement {
    #[must_use]
    pub fn as_flag(&self) -> Option<&FlagStatement> {
        if let Self::Flag(v) = self {
            Some(v)
        } else {
            None
        }
    }
}

/// Generic structure for statements that accept display options.
#[derive(Debug, Parse)]
pub struct Displayed<T: Parse> {
    /// The properties
    pub properties: Option<DisplayProperties>,
    /// The statement itself
    pub statement: T,
}

/// A utility struct for collections of parsed items with punctuators between them.
#[derive(Debug, Clone, Parse)]
pub struct Punctuated<T: Parse, P: Parse> {
    /// The first parsed item.
    pub first: Box<T>,
    /// The next items with punctuators.
    pub collection: Vec<(P, T)>,
}

impl<T: Parse, P: Parse> Punctuated<T, P> {
    /// Creates a new instance of `Punctuated`.
    #[must_use]
    pub fn new(first: T) -> Punctuated<T, P> {
        Self {
            first: Box::new(first),
            collection: Vec::new(),
        }
    }

    /// Turns the punctuated into an iterator on the items.
    pub fn iter(&self) -> impl Iterator<Item = &T> {
        vec![self.first.as_ref()]
            .into_iter()
            .chain(self.collection.iter().map(|x| &x.1))
    }

    /// Turns the punctuated into an iterator on the items.
    pub fn into_parsed_iter(self) -> impl Iterator<Item = T> {
        vec![*self.first]
            .into_iter()
            .chain(self.collection.into_iter().map(|x| x.1))
    }

    /// Gets the item count.
    #[must_use]
    pub fn len(&self) -> usize {
        self.collection.len() + 1
    }

    /// Checks if there are no items (always false).
    #[must_use]
    pub fn is_empty(&self) -> bool {
        false
    }

    /// Tries to get the element on `index`.
    #[must_use]
    pub fn get(&self, index: usize) -> Option<&T> {
        match index {
            0 => Some(&self.first),
            _ => self.collection.get(index - 1).map(|x| &x.1),
        }
    }
}

impl Parse for TokInteger {
    type FirstToken = NumberLit;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        match input.get_token()? {
            Token::NumberLit(NumberLit::Integer(tok)) => Ok(tok.clone()),
            t => Err(Error::InvalidToken { token: t.clone() }),
        }
    }

    fn get_span(&self) -> Span {
        self.span
    }
}

impl Parse for NamedIdent {
    type FirstToken = Ident;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        match input.get_token()? {
            Token::Ident(Ident::Named(named)) => Ok(named.clone()),
            t => Err(Error::InvalidToken { token: t.clone() }),
        }
    }

    fn get_span(&self) -> Span {
        self.span
    }
}

impl<T: Parse> Parse for Box<T> {
    type FirstToken = T::FirstToken;

    fn parse<'r, I: Iterator<Item = &'r Token> + Clone>(
        input: &mut InputStream<'r, I>,
    ) -> Result<Self, Error> {
        Ok(Box::new(input.parse()?))
    }

    fn get_span(&self) -> Span {
        (**self).get_span()
    }
}

/// A builtin type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Type {
    /// A point
    Point,
    /// A line
    Line,
    /// A number with a certain unit.
    Number(Option<ComplexUnit>),
    /// A point collection.
    PointCollection(usize),
    /// A circle
    Circle,
    /// A derived type.
    Derived(&'static str),
    /// Marks unknown type. Unknown type pretends to be valid, but isn't really.
    Unknown,
}

impl Type {
    #[must_use]
    pub fn as_number(&self) -> Option<&Option<ComplexUnit>> {
        if let Self::Number(v) = self {
            Some(v)
        } else {
            None
        }
    }
}

/// A user-defined type.
pub struct DefinedType {
    /// The type's name.
    pub name: String,
}

impl Display for Type {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Point => write!(f, "Point"),
            Self::Line => write!(f, "Line"),
            Self::Number(unit) => match unit {
                Some(unit) => write!(f, "Number ({unit})"),
                None => write!(f, "Number (no unit)"),
            },
            Self::PointCollection(l) => write!(f, "Point collection ({l})"),
            Self::Circle => write!(f, "Circle"),
            Self::Derived(name) => write!(f, "{name}"),
            Type::Unknown => write!(f, "undefined"),
        }
    }
}

impl Type {
    /// Whether `self` can be cast to `into`.
    #[must_use]
    pub fn can_cast(&self, into: &Type) -> bool {
        match self {
            // A point can only be cast into another point or a point collection with length one.
            Type::Point => matches!(into, Type::Point | Type::PointCollection(1)),
            // A line can only be cast into another line.
            Type::Line => matches!(into, Type::Line),
            // A number with a defined unit can only be cast into another number with the same unit.
            Type::Number(Some(unit1)) => {
                if let Type::Number(Some(unit2)) = into {
                    unit1 == unit2
                } else {
                    false
                }
            }
            // A number with no defined unit can be cast into any other number, except angle.
            Type::Number(None) => match into {
                Type::Number(unit) => match unit {
                    Some(unit) => unit.0[1].is_zero(), // no angle
                    None => true,
                },
                _ => false,
            },
            Type::PointCollection(l) => match into {
                Type::Point => *l == 1,
                Type::Line => *l == 2,
                Type::Number(Some(u)) => *u == unit::DISTANCE && *l == 2,
                Type::PointCollection(v) => v == l || *v == 0,
                _ => false,
            },
            Type::Circle => matches!(into, Type::Circle),
            Type::Derived(name) => {
                if into == self {
                    true
                } else if let Type::PointCollection(count) = into {
                    library::get_derived_pc(name) == *count
                } else {
                    false
                }
            }
            Type::Unknown => true,
        }
    }
}

/// A property
#[derive(Debug, Clone, Parse)]
pub struct Property {
    /// Property name.
    pub name: NamedIdent,
    /// '='
    pub eq: Eq,
    /// Property value.
    pub value: PropertyValue,
}

/// A property's value
#[derive(Debug, Clone, Parse)]
pub enum PropertyValue {
    Number(NumberLit),
    Ident(Ident),
    RawString(RawString),
    String(StrLit),
}

impl Display for PropertyValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Number(n) => write!(f, "{n}"),
            Self::Ident(i) => write!(f, "{i}"),
            Self::RawString(s) => write!(f, "!{}", s.lit),
            Self::String(s) => write!(f, "{s}"),
        }
    }
}

/// A raw string line `!"Hello, World!"`. Does not parse any special characters.
#[derive(Debug, Clone, Parse)]
pub struct RawString {
    pub excl: Exclamation,
    /// The string contents.
    pub lit: StrLit,
}

/// Trait for conversion of properties into actual types.
pub trait FromProperty: Sized {
    /// Try to convert the property value into `Self`.
    ///
    /// # Errors
    /// Causes an error if the value is not properly convertible.
    fn from_property(property: PropertyValue) -> Result<Self, Error>;
}

impl<T: FromProperty> FromProperty for Result<T, Error> {
    fn from_property(property: PropertyValue) -> Result<Self, Error> {
        Ok(T::from_property(property))
    }
}

impl FromProperty for bool {
    fn from_property(property: PropertyValue) -> Result<Self, Error> {
        match property {
            PropertyValue::Ident(ident) => match ident {
                Ident::Named(ident) => match ident.ident.as_str() {
                    "enabled" | "on" | "true" | "yes" => Ok(true),
                    "disabled" | "off" | "false" | "no" => Ok(false),
                    _ => Err(Error::BooleanExpected {
                        error_span: ident.get_span(),
                    }),
                },
                Ident::Collection(_) => Err(Error::BooleanExpected {
                    error_span: ident.get_span(),
                }),
            },
            PropertyValue::Number(num) => match num {
                NumberLit::Integer(i) => match i.parsed.parse::<u8>() {
                    Ok(0) => Ok(false),
                    Ok(1) => Ok(true),
                    _ => Err(Error::BooleanExpected { error_span: i.span }),
                },
                NumberLit::Float(f) => Err(Error::BooleanExpected { error_span: f.span }),
            },
            PropertyValue::String(s) => match s.content.as_str() {
                "enabled" | "on" | "true" | "yes" => Ok(true),
                "disabled" | "off" | "false" | "no" => Ok(false),
                _ => Err(Error::BooleanExpected {
                    error_span: s.get_span(),
                }),
            },
            PropertyValue::RawString(s) => Err(Error::BooleanExpected {
                error_span: s.get_span(),
            }),
        }
    }
}

impl FromProperty for String {
    fn from_property(property: PropertyValue) -> Result<String, Error> {
        match property {
            PropertyValue::Ident(ident) => Ok(ident.to_string()),
            PropertyValue::Number(num) => Err(Error::StringExpected {
                error_span: num.get_span(),
            }),
            PropertyValue::RawString(s) => Ok(s.lit.content),
            PropertyValue::String(s) => Ok(s.content),
        }
    }
}

impl FromProperty for ProcNum {
    fn from_property(property: PropertyValue) -> Result<Self, Error> {
        match property {
            PropertyValue::Number(num) => Ok(ProcNum::from(&num)),
            PropertyValue::RawString(s) => Err(Error::NumberExpected {
                error_span: s.get_span(),
            }),
            PropertyValue::String(s) => Err(Error::NumberExpected {
                error_span: s.get_span(),
            }),
            PropertyValue::Ident(ident) => Err(Error::NumberExpected {
                error_span: ident.get_span(),
            }),
        }
    }
}

/// Properties usually related to displaying things.
#[derive(Debug, Clone, Parse)]
pub struct DisplayProperties {
    /// '['
    pub lsquare: LSquare,
    /// Properties
    pub properties: Punctuated<Property, Semi>,
    /// ']'
    pub rsquare: RSquare,
}