lehit 0.2.0

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

use crate::parsing::{
    Span,
    ast::{
        AccessExpression, ContractDefinitionContent, Expression, GenericList, IdentName, Mutable,
        ParsingState, ValueType, access_expression_parser, ident_name_parser, mutable_parser,
        value_type_parser,
    },
    lexer::{Token, TokensData},
};

#[derive(Debug, Clone)]
pub enum Statement {
    Declaration(Box<DeclarationStatement>),
    Assignment(Box<AssignmentStatement>),
    Expression(Box<Expression>),
    Return(Box<ReturnStatement>),
}

#[derive(Debug, Clone)]
pub struct DeclarationStatement {
    pub span: Span,
    pub item: DeclarationStatementItem,
    pub expression: Option<Expression>,
}

#[derive(Debug, Clone)]
pub enum DeclarationStatementItem {
    Ident(Box<DeclarationStatementIdentItem>),
    Group(Box<DeclarationStatementGroupItem>),
}

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

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

#[derive(Debug, Clone)]
pub struct AssignmentStatement {
    pub span: Span,
    pub dereference_count: usize,
    pub access: AccessExpression,
    pub operator: AssignmentOperator,
    pub expression: Expression,
}

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

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssignmentOperatorKind {
    Set,
    Add,
    Sub,
    Multiply,
    Divide,
    ShiftLeft,
    ShiftRight,
}

#[derive(Debug, Clone)]
pub struct ReturnStatement {
    pub span: Span,
    pub expression: Option<Expression>,
}

pub(crate) fn statement_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, Statement, 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,
{
    choice((
        assignment_statement_parser(
            tokens_data,
            state,
            expression_parser.clone(),
            generic_list_parser.clone(),
            contract_definition_content_parser.clone(),
        )
        .map(|assignment| Statement::Assignment(Box::new(assignment))),
        expression_parser
            .clone()
            .map(|expression| Statement::Expression(Box::new(expression))),
        declaration_statement_parser(
            tokens_data,
            state,
            expression_parser.clone(),
            generic_list_parser,
            contract_definition_content_parser,
        )
        .map(|ds| Statement::Declaration(Box::new(ds))),
        return_statement_parser(expression_parser).map(|rs| Statement::Return(Box::new(rs))),
    ))
}

pub(crate) fn declaration_statement_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, DeclarationStatement, 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,
{
    just(Token::LetKw)
        .ignore_then(declaration_statement_item_parser(
            tokens_data,
            state,
            generic_list_parser,
            contract_definition_content_parser,
        ))
        .then(just(Token::Eq).ignore_then(expression_parser).or_not())
        .map_with(|(dsi, expression), ex| DeclarationStatement {
            span: ex.span(),
            item: dsi,
            expression: expression,
        })
}

pub(crate) fn declaration_statement_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, DeclarationStatementItem, 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,
{
    recursive(|declaration_statement_item_parser| {
        let group_parser = declaration_statement_item_parser
            .clone()
            .then(
                just(Token::Comma).ignore_then(
                    declaration_statement_item_parser
                        .separated_by(just(Token::Comma))
                        .allow_trailing()
                        .collect::<Vec<_>>(),
                ),
            )
            .delimited_by(just(Token::OpenParen), just(Token::CloseParen))
            .map_with(|(first, rest), ex| DeclarationStatementGroupItem {
                span: ex.span(),
                items: (first, rest),
            });

        group_parser
            .map(|dsgi| DeclarationStatementItem::Group(Box::new(dsgi)))
            .or(declaration_statement_ident_item_parser(
                tokens_data,
                state,
                generic_list_parser,
                contract_definition_content_parser,
            )
            .map(|dsii| DeclarationStatementItem::Ident(Box::new(dsii))))
    })
}

pub(crate) fn declaration_statement_ident_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, DeclarationStatementIdentItem, 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,
{
    mutable_parser()
        .or_not()
        .then(ident_name_parser(tokens_data, state))
        .then(
            just(Token::Colon)
                .ignore_then(value_type_parser(
                    tokens_data,
                    state,
                    generic_list_parser,
                    contract_definition_content_parser,
                ))
                .or_not(),
        )
        .map_with(|((mutable, ident), vt), ex| DeclarationStatementIdentItem {
            span: ex.span(),
            mutable: mutable,
            ident: ident,
            value_type: vt,
        })
}

pub(crate) fn assignment_statement_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, AssignmentStatement, 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,
{
    just(Token::Asterisk)
        .repeated()
        .collect::<Vec<_>>()
        .then(access_expression_parser(
            tokens_data,
            state,
            expression_parser.clone(),
            generic_list_parser,
            contract_definition_content_parser,
        ))
        .then(assignment_operator_parser())
        .then(expression_parser)
        .map_with(
            |(((dereferences, access), operator), expression), ex| AssignmentStatement {
                span: ex.span(),
                dereference_count: dereferences.len(),
                access,
                operator,
                expression,
            },
        )
}

pub(crate) fn assignment_operator_parser<'src, I>()
-> impl Parser<'src, I, AssignmentOperator, extra::Err<Rich<'src, Token, Span>>> + Clone
where
    I: Input<'src, Token = Token, Span = Span>,
{
    select! {
        Token::Eq => AssignmentOperatorKind::Set,
        Token::PlusEq => AssignmentOperatorKind::Add,
        Token::MinusEq => AssignmentOperatorKind::Sub,
        Token::AsteriskEq => AssignmentOperatorKind::Multiply,
        Token::SlashEq => AssignmentOperatorKind::Divide,
        Token::ShiftLeftEq => AssignmentOperatorKind::ShiftLeft,
        Token::ShiftRightEq => AssignmentOperatorKind::ShiftRight,
    }
    .map_with(|kind, ex| AssignmentOperator {
        span: ex.span(),
        kind,
    })
}

pub(crate) fn return_statement_parser<'src, I, EP>(
    expression_parser: EP,
) -> impl Parser<'src, I, ReturnStatement, 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,
{
    just(Token::ReturnKw)
        .ignore_then(expression_parser.or_not())
        .map_with(|expression, ex| ReturnStatement {
            span: ex.span(),
            expression: expression,
        })
}