lehit 0.2.0

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

use crate::parsing::{
    Span,
    ast::{
        ContractAccessDeclaration, ContractAccessPath, Expression, FileContractDeclaration,
        GenericList, IdentName, ParsingState, PubVisible, Statement, ValueType,
        contract_access_declaration_parser, contract_access_path_parser,
        file_contract_declaration_parser, ident_name_parser, pub_visible_parser, statement_parser,
    },
    lexer::{Token, TokensData},
};

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

#[derive(Debug, Clone, Default)]
pub struct ContractDefinitionContent {
    pub contract_accesses: Vec<ContractAccessDeclaration>,
    pub field_declarations: Vec<StructureFieldDeclaration>,
    pub variant_declarations: Vec<EnumVariantDeclaration>,
    pub trait_implementations: Vec<TraitImplementationDeclaration>,
    pub statements: Vec<Statement>,
}

#[derive(Debug, Clone)]
pub struct StructureFieldDeclaration {
    pub span: Span,
    pub pub_visible: Option<PubVisible>,
    pub ident: IdentName,
    pub value_type: ValueType,
    pub default_expression: Option<Expression>,
}

#[derive(Debug, Clone)]
pub struct EnumVariantDeclaration {
    pub span: Span,
    pub ident: IdentName,
    pub value_type: Option<ValueType>,
}

#[derive(Debug, Clone)]
pub struct TraitImplementationDeclaration {
    pub span: Span,
    pub trait_path: ContractAccessPath,
    pub definition: Option<ContractDefinition>,
}

pub(crate) fn contract_definition_parser<'src, I, CDCP>(
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ContractDefinition, 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,
{
    contract_definition_content_parser
        .delimited_by(just(Token::OpenBrace), just(Token::CloseBrace))
        .map_with(|content, ex| ContractDefinition {
            span: ex.span(),
            content: content,
        })
}

#[derive(Debug, Clone)]
enum ContractDefinitionContentItem {
    Acs(ContractAccessDeclaration),
    Fld(StructureFieldDeclaration),
    Var(EnumVariantDeclaration),
    Impl(TraitImplementationDeclaration),
    Statement(Statement),
}

impl ContractDefinitionContentItem {
    fn push_to(self, content: &mut ContractDefinitionContent) {
        match self {
            ContractDefinitionContentItem::Acs(cad) => content.contract_accesses.push(cad),
            ContractDefinitionContentItem::Fld(sfd) => content.field_declarations.push(sfd),
            ContractDefinitionContentItem::Var(evd) => content.variant_declarations.push(evd),
            ContractDefinitionContentItem::Impl(implementation) => {
                content.trait_implementations.push(implementation)
            }
            ContractDefinitionContentItem::Statement(statement) => {
                content.statements.push(statement)
            }
        }
    }
}

fn contract_definition_content_item_parser<'src, I, EP, GLP, VTP, CDCP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    generic_list_parser: GLP,
    value_type_parser: VTP,
    contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ContractDefinitionContentItem, 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,
    VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
    CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
        + Clone
        + 'src,
{
    choice((
        contract_access_declaration_parser(
            tokens_data,
            state,
            generic_list_parser.clone(),
            value_type_parser.clone(),
            contract_definition_content_parser.clone(),
        )
        .map(ContractDefinitionContentItem::Acs),
        structure_field_declaration_parser(
            tokens_data,
            state,
            expression_parser.clone(),
            value_type_parser.clone(),
        )
        .map(ContractDefinitionContentItem::Fld),
        enum_variant_declaration_parser(tokens_data, state, value_type_parser)
            .map(ContractDefinitionContentItem::Var),
        trait_implementation_declaration_parser(
            tokens_data,
            state,
            generic_list_parser.clone(),
            contract_definition_content_parser.clone(),
        )
        .map(ContractDefinitionContentItem::Impl),
        statement_parser(
            tokens_data,
            state,
            expression_parser,
            generic_list_parser,
            contract_definition_content_parser,
        )
        .map(ContractDefinitionContentItem::Statement),
    ))
}

pub(crate) fn contract_definition_content_parser<'src, I, EP, GLP, VTP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    generic_list_parser: GLP,
    value_type_parser: VTP,
) -> impl Parser<'src, I, ContractDefinitionContent, 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,
    VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    recursive(|contract_definition_content_parser| {
        empty().map(|_| ContractDefinitionContent::default()).foldl(
            contract_definition_content_item_parser(
                tokens_data,
                state,
                expression_parser,
                generic_list_parser,
                value_type_parser,
                contract_definition_content_parser,
            )
            .then_ignore(just(Token::Semicolon).or_not())
            .repeated(),
            |mut content, item| {
                item.push_to(&mut content);
                content
            },
        )
    })
}

pub(crate) fn contract_definition_content_with_file_contract_declarations_parser<
    'src,
    I,
    EP,
    GLP,
    VTP,
    CDCP,
>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    generic_list_parser: GLP,
    value_type_parser: VTP,
    contract_definition_content_parser: CDCP,
) -> impl Parser<
    'src,
    I,
    (ContractDefinitionContent, Vec<FileContractDeclaration>),
    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,
    VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
    CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
        + Clone
        + 'src,
{
    enum Item {
        Content(ContractDefinitionContentItem),
        FileContract(FileContractDeclaration),
    }

    let item_parser = choice((
        contract_definition_content_item_parser(
            tokens_data,
            state,
            expression_parser.clone(),
            generic_list_parser.clone(),
            value_type_parser.clone(),
            contract_definition_content_parser.clone(),
        )
        .map(Item::Content),
        file_contract_declaration_parser(
            tokens_data,
            state,
            generic_list_parser,
            value_type_parser,
        )
        .map(Item::FileContract),
    ));

    empty()
        .map(|_| (ContractDefinitionContent::default(), Vec::new()))
        .foldl(
            item_parser
                .then_ignore(just(Token::Semicolon).or_not())
                .repeated(),
            |(mut content, mut file_contracts), item| {
                match item {
                    Item::Content(item) => item.push_to(&mut content),
                    Item::FileContract(fc) => file_contracts.push(fc),
                }

                (content, file_contracts)
            },
        )
}

pub(crate) fn trait_implementation_declaration_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, TraitImplementationDeclaration, 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,
{
    just(Token::ImplKw)
        .ignore_then(contract_access_path_parser(
            tokens_data,
            state,
            generic_list_parser,
        ))
        .then(contract_definition_parser(contract_definition_content_parser).or_not())
        .map_with(
            |(trait_path, definition), extra| TraitImplementationDeclaration {
                span: extra.span(),
                trait_path,
                definition,
            },
        )
}

pub(crate) fn structure_field_declaration_parser<'src, I, EP, VTP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    expression_parser: EP,
    value_type_parser: VTP,
) -> impl Parser<'src, I, StructureFieldDeclaration, 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,
    VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    pub_visible_parser()
        .or_not()
        .then_ignore(just(Token::FldKw))
        .then(ident_name_parser(tokens_data, state))
        .then_ignore(just(Token::Colon))
        .then(value_type_parser)
        .then(just(Token::Eq).ignore_then(expression_parser).or_not())
        .map_with(
            |(((pv, ident), vt), def_expr), ex| StructureFieldDeclaration {
                span: ex.span(),
                pub_visible: pv,
                ident: ident,
                value_type: vt,
                default_expression: def_expr,
            },
        )
}

pub(crate) fn enum_variant_declaration_parser<'src, I, VTP>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
    value_type_parser: VTP,
) -> impl Parser<'src, I, EnumVariantDeclaration, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
    VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
    just(Token::VarKw)
        .ignore_then(ident_name_parser(tokens_data, state))
        .then(value_type_parser.or_not())
        .map_with(|(ident, vt), ex| EnumVariantDeclaration {
            span: ex.span(),
            ident: ident,
            value_type: vt,
        })
}