lehit 0.2.0

Embeddable Lehit language frontend and Cranelift JIT runtime
Documentation
use chumsky::prelude::*;

use crate::parsing::{
    Span,
    ast::{
        ContractAccessPath, ContractDefinitionContent, IdentName, Lifetime, ParsingState,
        ValueType, contract_access_path_parser, ident_name_parser, lifetime_parser,
        value_type_parser,
    },
    lexer::{Token, TokensData},
};

#[derive(Debug, Clone)]
pub struct GenericList {
    pub span: Span,
    pub items: (GenericItem, Vec<GenericItem>),
}

#[derive(Debug, Clone)]
pub enum GenericItem {
    Lifetime(Lifetime),
    ValueType(ValueType),
}

impl GenericItem {
    pub fn span(&self) -> Span {
        match self {
            GenericItem::Lifetime(item) => item.span,
            GenericItem::ValueType(item) => item.span(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct GenericDeclarationList {
    pub span: Span,
    pub items: (GenericDeclarationItem, Vec<GenericDeclarationItem>),
}

#[derive(Debug, Clone)]
pub enum GenericDeclarationItem {
    Lifetime(Lifetime),
    Type(Box<GenericDeclarationTypeItem>),
}

impl GenericDeclarationItem {
    pub fn span(&self) -> Span {
        match self {
            GenericDeclarationItem::Lifetime(item) => item.span,
            GenericDeclarationItem::Type(item) => item.span,
        }
    }
}

#[derive(Debug, Clone)]
pub struct GenericDeclarationTypeItem {
    pub span: Span,
    pub ident: IdentName,
    pub constraints: Vec<GenericDeclarationTypeItemConstraint>,
}

#[derive(Debug, Clone)]
pub enum GenericDeclarationTypeItemConstraint {
    Lifetime(Box<Lifetime>),
    Type(Box<ContractAccessPath>),
}

impl GenericDeclarationTypeItemConstraint {
    pub fn span(&self) -> Span {
        match self {
            Self::Lifetime(lt) => lt.span,
            Self::Type(ty) => ty.span,
        }
    }
}

pub(crate) fn generic_list_parser<'src, I, CDCP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
        + Clone
        + 'src,
{
    recursive(|generic_list_parser| {
        generic_item_parser(
            tokens_data,
            state,
            generic_list_parser.clone(),
            contract_definition_content_parser.clone(),
        )
        .then(
            just(Token::Comma)
                .ignore_then(generic_item_parser(
                    tokens_data,
                    state,
                    generic_list_parser,
                    contract_definition_content_parser,
                ))
                .repeated()
                .collect::<Vec<_>>(),
        )
        .then_ignore(just(Token::Comma).or_not())
        .delimited_by(just(Token::LeftAngle), just(Token::RightAngle))
        .map_with(|(first, rest), ex| GenericList {
            span: ex.span(),
            items: (first, rest),
        })
    })
}

pub(crate) fn generic_item_parser<'src, I, GLP, CDCP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, GenericItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
    CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
        + Clone
        + 'src,
{
    lifetime_parser(tokens_data, state)
        .map(|lt| GenericItem::Lifetime(lt))
        .or(value_type_parser(
            tokens_data,
            state,
            generic_list_parser,
            contract_definition_content_parser,
        )
        .map(|vt| GenericItem::ValueType(vt)))
}

pub(crate) fn generic_declaration_list_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationList, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    generic_declaration_item_parser(tokens_data, state, generic_list_parser.clone())
        .then(
            just(Token::Comma)
                .ignore_then(generic_declaration_item_parser(
                    tokens_data,
                    state,
                    generic_list_parser,
                ))
                .repeated()
                .collect::<Vec<_>>(),
        )
        .then_ignore(just(Token::Comma).or_not())
        .delimited_by(just(Token::LeftAngle), just(Token::RightAngle))
        .map_with(|(first, rest), ex| GenericDeclarationList {
            span: ex.span(),
            items: (first, rest),
        })
}

pub(crate) fn generic_declaration_item_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    lifetime_parser(tokens_data, state)
        .map(|lt| GenericDeclarationItem::Lifetime(lt))
        .or(
            generic_declaration_type_item_parser(tokens_data, state, generic_list_parser)
                .map(|gdti| GenericDeclarationItem::Type(Box::new(gdti))),
        )
}

pub(crate) fn generic_declaration_type_item_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationTypeItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    ident_name_parser(tokens_data, state)
        .then(
            just(Token::Colon)
                .ignore_then(
                    generic_declaration_type_item_constraint_parser(
                        tokens_data,
                        state,
                        generic_list_parser,
                    )
                    .separated_by(just(Token::Plus))
                    .at_least(1)
                    .collect::<Vec<_>>(),
                )
                .or_not()
                .map(Option::unwrap_or_default),
        )
        .map_with(|(ident, constraints), ex| GenericDeclarationTypeItem {
            span: ex.span(),
            ident: ident,
            constraints: constraints,
        })
}

pub(crate) fn generic_declaration_type_item_constraint_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationTypeItemConstraint, extra::Err<Rich<'src, Token, Span>>>
+ Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    lifetime_parser(tokens_data, state)
        .map(|lt| GenericDeclarationTypeItemConstraint::Lifetime(Box::new(lt)))
        .or(
            contract_access_path_parser(tokens_data, state, generic_list_parser)
                .map(|path| GenericDeclarationTypeItemConstraint::Type(Box::new(path))),
        )
}