lehit 0.2.0

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

use crate::parsing::{
    Span,
    ast::{
        ContractDefinitionContent, Expression, FileContractDeclaration, GenericList, ParsingState,
        ValueType, contract_definition_content_parser,
        contract_definition_content_with_file_contract_declarations_parser, expression_parser,
        generic_list_parser, value_type_parser,
    },
    lexer::{Token, TokensData},
};

#[derive(Debug, Clone)]
pub struct File {
    pub file_contract_declarations: Vec<FileContractDeclaration>,
    pub contract_definition_content: ContractDefinitionContent,
}

/// Builds the complete mutually-recursive grammar used by the public parsing API.
pub(crate) fn complete_file_parser<'src, I>(
    tokens_data: &'src TokensData,
    state: &'src ParsingState,
) -> impl Parser<'src, I, File, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
{
    let mut expression = Recursive::declare();
    let mut generic_list = Recursive::declare();
    let mut value_type = Recursive::declare();
    let mut content = Recursive::declare();

    expression.define(expression_parser(
        tokens_data,
        state,
        generic_list.clone(),
        content.clone(),
    ));
    generic_list.define(generic_list_parser(tokens_data, state, content.clone()));
    value_type.define(value_type_parser(
        tokens_data,
        state,
        generic_list.clone(),
        content.clone(),
    ));
    content.define(contract_definition_content_parser(
        tokens_data,
        state,
        expression.clone(),
        generic_list.clone(),
        value_type.clone(),
    ));

    file_parser(
        tokens_data,
        state,
        expression,
        generic_list,
        value_type,
        content,
    )
}

pub(crate) fn file_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, File, 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,
{
    contract_definition_content_with_file_contract_declarations_parser(
        tokens_data,
        state,
        expression_parser,
        generic_list_parser,
        value_type_parser,
        contract_definition_content_parser,
    )
    .map(|(content, contracts)| File {
        file_contract_declarations: contracts,
        contract_definition_content: content,
    })
    .then_ignore(just(Token::Eof))
}