mirascript-core 0.1.105

Compiler and bytecode definitions for the MiraScript language
Documentation
use winnow::{
    combinator::{alt, dispatch, fail, opt, peek, seq},
    token::{any, one_of},
};

use super::{
    block_expressions::*,
    expressions::{expression, expression_or_insert},
    helper::{token, token_or_insert, variable_token},
    parameter_list::parameter_list,
    patterns::pattern_or_insert,
    prelude::*,
};

pub(super) fn semicolon<'s>(i: &mut Input<'s>) -> Result<TokenRef<'s>> {
    token_or_insert(Operator::Semicolon, DiagnosticCode::MissingSemicolon).parse_next(i)
}

fn empty_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    token(Operator::Semicolon)
        .map(Statement::Empty)
        .parse_next(i)
}

fn fn_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    (
        opt(token(Keyword::Pub)),
        token(Keyword::Fn),
        opt(variable_token(false, false)),
        parameter_list,
        block_expression.map(Box::new),
    )
        .map(|(kw_pub, kw_fn, name, params, body)| {
            let mut name = name.unwrap_or_else(|| {
                Token::unknown_at(
                    kw_fn.range.end,
                    TokenKind::Identifier("<name>"),
                    DiagnosticCode::MissingFunctionName,
                )
                .into()
            });
            if name.to_id_name() == Some("type") {
                name.wrap_as_unknown(DiagnosticCode::MissingOpenParenAfterType);
            }
            Statement::Function(kw_pub, kw_fn, name, params, body)
        })
        .parse_next(i)
}

fn return_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Return(
        token(Keyword::Return),
        opt(expression.map(Box::new)),
        semicolon,
    ))
    .parse_next(i)
}

fn break_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Break(
        token(Keyword::Break),
        opt(expression.map(Box::new)),
        semicolon,
    ))
    .parse_next(i)
}

fn continue_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Continue(token(Keyword::Continue), semicolon,)).parse_next(i)
}

fn bind_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Bind(
        opt(token(Keyword::Pub)),
        token(Keyword::Let),
        pattern_or_insert(false, |t| *t == Operator::Assign).map(Box::new),
        token_or_insert(Operator::Assign, DiagnosticCode::MissingBindOperator),
        expression_or_insert(|t| *t == Operator::Semicolon).map(Box::new),
        semicolon,
    ))
    .parse_next(i)
}

fn rebind_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Rebind(
        pattern_or_insert(true, |t| *t == Operator::Assign).map(Box::new),
        token(Operator::Assign),
        expression_or_insert(|t| *t == Operator::Semicolon).map(Box::new),
        semicolon,
    ))
    .parse_next(i)
}

fn const_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    seq!(Statement::Const(
        opt(token(Keyword::Pub)),
        token(Keyword::Const),
        variable_token(false, false).map(|mut t| {
            if t.to_id_name().is_some_and(|name| !name.starts_with('@')) {
                t.wrap_as_unknown(DiagnosticCode::InvalidConstantName)
            }
            t
        }),
        token_or_insert(Operator::Assign, DiagnosticCode::MissingBindOperator),
        expression_or_insert(|t| *t == Operator::Semicolon).map(Box::new),
        semicolon,
    ))
    .parse_next(i)
}

fn insert_semicolon<'s>(i: &mut Input<'s>) -> Result<()> {
    peek(one_of(|t: &Token<'s>| {
        *t != Operator::CloseBrace
            && *t != TokenKind::Eof
            && *t != Keyword::Case
            && *t != Keyword::Else
    }))
    .value(())
    .parse_next(i)
}

fn assign_or_expression_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    fn is_assign_op(t: &Token<'_>) -> bool {
        matches!(t.kind, TokenKind::Operator(t) if t == Operator::Assign || t.is_compound())
    }

    // Common expr of expr1 = expr2; and expr1;
    let expr1 = expression_or_insert(is_assign_op)
        .map(Box::new)
        .parse_next(i)?;
    let cp = i.checkpoint();
    // Try to parse as assignment first
    let assign: Result<_> = one_of(is_assign_op).parse_next(i);
    if let Ok(assign) = assign {
        let expr2 = expression_or_insert(|t| *t == Operator::Semicolon)
            .map(Box::new)
            .parse_next(i)?;
        let semi = semicolon.parse_next(i)?;
        return Ok(Statement::Assign(
            expr1,
            TokenRef::borrow(assign),
            expr2,
            semi,
        ));
    }
    // Fallback to expression statement
    i.reset(&cp);
    insert_semicolon.parse_next(i)?;
    let semi = semicolon.parse_next(i)?;
    Ok(Statement::Expression(expr1, semi))
}

fn unknown_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    fail.map(|t: &[Token<'s>]| {
        Statement::unknown(
            t.iter().map(TokenRef::borrow).collect::<Vec<_>>(),
            DiagnosticCode::UnknownStatement,
        )
    })
    .parse_next(i)
}

fn mod_statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    (
        opt(token(Keyword::Pub)),
        token(Keyword::Mod),
        opt(variable_token(false, false)),
        block_expression_no_expr.map(Box::new),
    )
        .map(|(kw_pub, kw_mod, name, body)| {
            let name = name.unwrap_or_else(|| {
                Token::unknown_at(
                    kw_mod.range.end,
                    TokenKind::Identifier("<name>"),
                    DiagnosticCode::MissingModuleName,
                )
                .into()
            });
            Statement::Module(kw_pub, kw_mod, name, body)
        })
        .parse_next(i)
}

pub(super) fn statement<'s>(i: &mut Input<'s>) -> Result<Statement<'s>> {
    dispatch! {peek(any);
        t if *t == Operator::OpenBrace => block_expression.map(Box::new).map(Statement::BlockExpression),
        t if *t == Keyword::If => if_expression.map(Box::new).map(Statement::BlockExpression),
        t if *t == Keyword::Loop => loop_expression.map(Box::new).map(Statement::BlockExpression),
        t if *t == Keyword::While => while_expression.map(Box::new).map(Statement::BlockExpression),
        t if *t == Keyword::Match => match_expression.map(Box::new).map(Statement::BlockExpression),
        t if *t == Keyword::For => for_in_expression.map(Box::new).map(Statement::BlockExpression),

        t if *t == Keyword::Return => return_statement,
        t if *t == Keyword::Break => break_statement,
        t if *t == Keyword::Continue => continue_statement,

        t if *t == Operator::Semicolon => empty_statement,

        &Token{..} => alt((
            mod_statement,
            fn_statement,
            const_statement,
            bind_statement,
            rebind_statement,
            assign_or_expression_statement,
            unknown_statement,
        )),
    }
    .parse_next(i)
}