lehit 0.2.0

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

use crate::parsing::{
    Span,
    ast::{
        ContractDefinitionContent, Expression, GenericList, IdentName, ParsingState,
        ValueExpression, ident_name_parser, value_expression_parser,
    },
    lexer::{Token, TokensData},
};

#[derive(Debug, Clone)]
pub struct AccessExpression {
    pub span: Span,
    pub entry: AccessExpressionEntry,
    pub accessors: Vec<AccessExpressionAccessor>,
}

#[derive(Debug, Clone)]
pub enum AccessExpressionEntry {
    ValueExpression(ValueExpression),
    Parenthesized(Box<Expression>),
    Ident(AccessExpressionIdent),
    Self_(AccessExpressionSelfEntry),
}

#[derive(Debug, Clone)]
pub struct AccessExpressionSelfEntry {
    pub span: Span,
}

#[derive(Debug, Clone)]
pub enum AccessExpressionAccessor {
    Next(Box<AccessExpressionNextAccessor>),
    Sub(Box<AccessExpressionSubAccessor>),
}

#[derive(Debug, Clone)]
pub enum AccessExpressionSubAccessor {
    Arguments(AccessExpressionAccessorArguments),
    Index(Expression),
}

#[derive(Debug, Clone)]
pub struct AccessExpressionAccessorArguments {
    pub span: Span,
    pub expressions: Vec<Expression>,
}

#[derive(Debug, Clone)]
pub enum AccessExpressionNextAccessor {
    Item(AccessExpressionNextAccessorItem),
    Ident(AccessExpressionIdent),
}

#[derive(Debug, Clone)]
pub struct AccessExpressionNextAccessorItem {
    pub span: Span,
    pub index: usize,
}

#[derive(Debug, Clone)]
pub struct AccessExpressionIdent {
    pub span: Span,
    pub ident: IdentName,
    pub generic_list: Option<GenericList>,
}

pub(crate) fn access_expression_parser<'src, I, EP, GLP, CDCP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    generic_list_parser: GLP,
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, AccessExpression, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
    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,
{
    access_expression_entry_parser(
        tokens_data,
        state,
        expression_parser.clone(),
        generic_list_parser.clone(),
        contract_definition_content_parser,
    )
    .then(
        choice((
            just(Token::Dot).ignore_then(
                access_expression_next_accessor_parser(tokens_data, state, generic_list_parser)
                    .map(|aena| AccessExpressionAccessor::Next(Box::new(aena))),
            ),
            access_expression_sub_accessor_parser(expression_parser)
                .map(|aesa| AccessExpressionAccessor::Sub(Box::new(aesa))),
        ))
        .repeated()
        .collect::<Vec<_>>(),
    )
    .map_with(|(entry, accessors), ex| AccessExpression {
        span: ex.span(),
        entry: entry,
        accessors: accessors,
    })
}

pub(crate) fn access_expression_entry_parser<'src, I, EP, GLP, CDCP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    generic_list_parser: GLP,
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, AccessExpressionEntry, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
    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,
{
    access_expression_ident_parser(tokens_data, state, generic_list_parser)
        .map(|aei| AccessExpressionEntry::Ident(aei))
        .or(expression_parser
            .clone()
            .delimited_by(just(Token::OpenParen), just(Token::CloseParen))
            .map(|expression| AccessExpressionEntry::Parenthesized(Box::new(expression))))
        .or(value_expression_parser(
            tokens_data,
            state,
            expression_parser,
            contract_definition_content_parser,
        )
        .map(|ve| AccessExpressionEntry::ValueExpression(ve)))
        .or(access_expression_self_entry_parser().map(|aese| AccessExpressionEntry::Self_(aese)))
}

pub(crate) fn access_expression_self_entry_parser<'src, I>()
-> impl Parser<'src, I, AccessExpressionSelfEntry, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
{
    just(Token::LowSelfKw)
        .to_span()
        .map(|span| AccessExpressionSelfEntry { span: span })
}

pub(crate) fn access_expression_next_accessor_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, AccessExpressionNextAccessor, 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,
{
    access_expression_ident_parser(tokens_data, state, generic_list_parser)
        .map(|aei| AccessExpressionNextAccessor::Ident(aei))
        .or(access_expression_next_accessor_item_parser(tokens_data)
            .map(|aenai| AccessExpressionNextAccessor::Item(aenai)))
}

pub(crate) fn access_expression_sub_accessor_parser<'src, I, EP>(
    expression_parser: EP,
) -> impl Parser<'src, I, AccessExpressionSubAccessor, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    access_expression_accessor_arguments_parser(expression_parser.clone())
        .map(|aeaa| AccessExpressionSubAccessor::Arguments(aeaa))
        .or(access_expression_accessor_index_parser(expression_parser)
            .map(|expression| AccessExpressionSubAccessor::Index(expression)))
}

pub(crate) fn access_expression_accessor_index_parser<'src, I, EP>(
    expression_parser: EP,
) -> impl Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    expression_parser.delimited_by(just(Token::OpenBracket), just(Token::CloseBracket))
}

pub(crate) fn access_expression_accessor_arguments_parser<'src, I, EP>(
    expression_parser: EP,
) -> impl Parser<'src, I, AccessExpressionAccessorArguments, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    crate::parsing::ast::empty_parentheses_parser()
        .map(|span| AccessExpressionAccessorArguments {
            span,
            expressions: Vec::new(),
        })
        .or(expression_parser
            .separated_by(just(Token::Comma))
            .allow_trailing()
            .collect::<Vec<_>>()
            .delimited_by(just(Token::OpenParen), just(Token::CloseParen))
            .map_with(|expressions, ex| AccessExpressionAccessorArguments {
                span: ex.span(),
                expressions,
            }))
}

pub(crate) fn access_expression_next_accessor_item_parser<'src, I>(
    tokens_data: &'src TokensData,
) -> impl Parser<'src, I, AccessExpressionNextAccessorItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
{
    select!(Token::IntAny(id) => tokens_data.get_i128(id))
        .try_map(|value, span| {
            usize::try_from(value)
                .map_err(|_| Rich::custom(span, "tuple index does not fit in usize"))
        })
        .map_with(|idx, ex| AccessExpressionNextAccessorItem {
            span: ex.span(),
            index: idx,
        })
}

pub(crate) fn access_expression_ident_parser<'src, I, GLP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    generic_list_parser: GLP,
) -> impl Parser<'src, I, AccessExpressionIdent, 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(generic_list_parser.or_not())
        .map_with(|(ident, gl), ex| AccessExpressionIdent {
            span: ex.span(),
            ident: ident,
            generic_list: gl,
        })
}