mirascript-core 0.1.105

Compiler and bytecode definitions for the MiraScript language
Documentation
use crate::{
    Operator, TokenKind,
    parser::{ElseBlock, Expression, MatchCase, Statement, TokenRef, precedence_of},
};

use super::prelude::*;

fn expression_precedence(token: &TokenKind<'_>) -> u8 {
    precedence_of(token).value
}

fn collect_infix<'s, 'a>(
    expression: &'a Expression<'s>,
    precedence: u8,
    operands: &mut Vec<&'a Expression<'s>>,
    operators: &mut Vec<&'a crate::parser::TokenRef<'s>>,
) {
    if let Expression::Infix(left, operator, right) = expression
        && expression_precedence(&operator.kind) == precedence
    {
        collect_infix(left, precedence, operands, operators);
        operators.push(operator);
        collect_infix(right, precedence, operands, operators);
    } else {
        operands.push(expression);
    }
}

fn format_infix(expression: &Expression<'_>, formatter: &Formatter) -> FormatDoc {
    let Expression::Infix(_, root_operator, _) = expression else {
        return expression.format(formatter);
    };
    let mut operands = Vec::new();
    let mut operators = Vec::new();
    collect_infix(
        expression,
        expression_precedence(&root_operator.kind),
        &mut operands,
        &mut operators,
    );
    let mut operands = operands.into_iter();
    let Some(first) = operands.next() else {
        return Formatter::nil();
    };
    let continuation = operators
        .into_iter()
        .zip(operands)
        .map(|(operator, operand)| {
            formatter
                .line()
                .append(formatter.token(operator))
                .append(formatter.space())
                .append(operand.format(formatter))
        });
    first
        .format(formatter)
        .append(formatter.indent(formatter.concat(continuation)))
        .group()
}

fn collect_extension_docs(
    expression: &Expression<'_>,
    formatter: &Formatter,
    extensions: &mut Vec<FormatDoc>,
) -> FormatDoc {
    let Expression::Extension(expression, colon_colon, callable, open, items, close) = expression
    else {
        return expression.format(formatter);
    };
    let base = collect_extension_docs(expression, formatter, extensions);
    extensions.push(
        formatter
            .token(colon_colon)
            .append(callable.format(formatter))
            .append(formatter.token(open))
            .append(items.format(formatter))
            .append(formatter.token(close)),
    );
    base
}

fn format_extension_chain(expression: &Expression<'_>, formatter: &Formatter) -> FormatDoc {
    let mut extensions = Vec::new();
    let base = collect_extension_docs(expression, formatter, &mut extensions);
    if extensions.len() == 1 {
        return base.append(extensions.pop().unwrap());
    }
    let continuation = extensions
        .into_iter()
        .map(|extension| formatter.line_().append(extension));
    base.append(formatter.indent(formatter.concat(continuation)))
        .group()
}

fn format_block_parts(
    open: &TokenRef<'_>,
    statements: &[Statement<'_>],
    expression: Option<&Expression<'_>>,
    close: &TokenRef<'_>,
    formatter: &Formatter,
    grouped: bool,
) -> FormatDoc {
    let close_comments = formatter.detached_leading_comments(&close.leading_trivia);
    if statements.is_empty() && expression.is_none() && close_comments.is_none() {
        return formatter
            .token(open)
            .append(formatter.space())
            .append(formatter.token_without_leading(close));
    }

    let mut body = formatter.join(
        statements
            .iter()
            .map(|statement| statement.format(formatter))
            .chain(expression.map(|expression| expression.format(formatter))),
        formatter.hardline(),
    );
    if let Some(close_comments) = close_comments {
        if !statements.is_empty() || expression.is_some() {
            body = body.append(formatter.hardline());
        }
        body = body.append(close_comments);
    }
    let boundary = if statements.is_empty()
        && expression.is_some_and(|expression| !expression.is_block_like())
        && close.leading_trivia.is_empty()
    {
        formatter.line()
    } else {
        formatter.hardline()
    };
    let doc = formatter
        .token(open)
        .append(formatter.indent(boundary.clone().append(body)))
        .append(boundary)
        .append(formatter.token_without_leading(close));
    if !grouped {
        return doc;
    }
    let normal = doc.group();
    if statements.is_empty()
        && close.leading_trivia.is_empty()
        && let Some(expression) = expression
        && !expression.is_block_like()
    {
        let inline = formatter
            .token(open)
            .append(formatter.space())
            .append(expression.format(formatter))
            .append(formatter.space())
            .append(formatter.token_without_leading(close));
        let inline_text = formatter.render(inline.clone(), 0);
        if !inline_text.contains('\n') && inline_text.chars().count() <= 20 {
            inline
        } else {
            normal
        }
    } else {
        normal
    }
}

fn format_if_expression(
    expression: &Expression<'_>,
    formatter: &Formatter,
    grouped: bool,
) -> FormatDoc {
    let Expression::If(keyword, condition, body, else_block) = expression else {
        return expression.format(formatter);
    };
    let body = match body.as_ref() {
        Expression::Block(open, statements, expression, close) => format_block_parts(
            open,
            statements,
            expression.as_deref(),
            close,
            formatter,
            false,
        ),
        body => body.format(formatter),
    };
    let else_block = else_block
        .as_ref()
        .map_or_else(Formatter::nil, |ElseBlock(keyword, body)| {
            let body = match body.as_ref() {
                Expression::Block(open, statements, expression, close) => format_block_parts(
                    open,
                    statements,
                    expression.as_deref(),
                    close,
                    formatter,
                    false,
                ),
                Expression::If(..) => format_if_expression(body, formatter, false),
                body => body.format(formatter),
            };
            formatter
                .space()
                .append(formatter.token(keyword))
                .append(formatter.space())
                .append(body)
        });
    let leading = formatter.leading_trivia(&keyword.leading_trivia);
    let doc = formatter
        .token_without_leading(keyword)
        .append(formatter.space())
        .append(condition.format(formatter))
        .append(formatter.space())
        .append(body)
        .append(else_block);
    leading.append(if grouped { doc.group() } else { doc })
}

impl Formattable for Expression<'_> {
    fn format(&self, formatter: &Formatter) -> FormatDoc {
        use Expression::*;
        match self {
            Literal(token) | Variable(token) => formatter.token(token),
            InterpolatedString(token, expressions) => formatter.string_token(token, expressions),
            Grouping(open, expression, close) => formatter
                .token(open)
                .append(expression.format(formatter))
                .append(formatter.token(close)),
            Record(open, items, close) => {
                let boundary = if **open == Operator::OpenBrace {
                    formatter.line()
                } else {
                    formatter.line_()
                };
                let force_tail = items.len() == 1 && items[0].is_unnamed();
                formatter
                    .token(open)
                    .append(formatter.list_items(items, boundary, force_tail))
                    .append(formatter.token(close))
            }
            Array(open, items, close) => formatter
                .token(open)
                .append(formatter.list_items(items, formatter.line_(), false))
                .append(formatter.token(close)),
            TaggedString(callable, expression) => {
                let callable = callable.format(formatter);
                let separator = if formatter.render(callable.clone(), 0).ends_with('@') {
                    formatter.space()
                } else {
                    Formatter::nil()
                };
                callable
                    .append(separator)
                    .append(expression.format(formatter))
            }
            Call(callable, open, items, close) => callable
                .format(formatter)
                .append(formatter.token(open))
                .append(items.format(formatter))
                .append(formatter.token(close)),
            Extension(..) => format_extension_chain(self, formatter),
            Access(expression, dot, field) => expression
                .format(formatter)
                .append(formatter.token(dot))
                .append(formatter.token(field)),
            Index(expression, open, field, close) => expression
                .format(formatter)
                .append(formatter.token(open))
                .append(field.format(formatter))
                .append(formatter.token(close)),
            Slice(expression, open, left, range, right, close) => expression
                .format(formatter)
                .append(formatter.token(open))
                .append(left.format(formatter))
                .append(formatter.token(range))
                .append(right.format(formatter))
                .append(formatter.token(close)),
            NonNil(expression, bang) => expression.format(formatter).append(formatter.token(bang)),
            Prefix(operator, expression) => formatter
                .token(operator)
                .append(if operator.is_keyword() {
                    formatter.space()
                } else {
                    Formatter::nil()
                })
                .append(expression.format(formatter)),
            Infix(left, operator, right) => {
                if **operator == Operator::Caret {
                    left.format(formatter)
                        .append(formatter.token(operator))
                        .append(right.format(formatter))
                } else {
                    let _ = (left, right);
                    format_infix(self, formatter)
                }
            }
            Is(expression, keyword, pattern) => expression
                .format(formatter)
                .append(formatter.space())
                .append(formatter.token(keyword))
                .append(formatter.indent(formatter.line().append(pattern.format(formatter))))
                .group(),
            Block(open, statements, expression, close) => format_block_parts(
                open,
                statements,
                expression.as_deref(),
                close,
                formatter,
                true,
            ),
            Loop(keyword, body) => formatter
                .token(keyword)
                .append(formatter.space())
                .append(body.format(formatter)),
            While(keyword, condition, body, else_block) => formatter
                .token(keyword)
                .append(formatter.space())
                .append(condition.format(formatter))
                .append(formatter.space())
                .append(body.format(formatter))
                .append(else_block.format(formatter)),
            ForIn(keyword_for, pattern, keyword_in, iterable, body, else_block) => formatter
                .token(keyword_for)
                .append(formatter.space())
                .append(pattern.format(formatter))
                .append(formatter.space())
                .append(formatter.token(keyword_in))
                .append(formatter.space())
                .append(iterable.format(formatter))
                .append(formatter.space())
                .append(body.format(formatter))
                .append(else_block.format(formatter)),
            Cond(condition, question, then_expression, colon, else_expression) => condition
                .format(formatter)
                .append(formatter.space())
                .append(formatter.token(question))
                .append(
                    formatter.indent(formatter.line().append(then_expression.format(formatter))),
                )
                .append(formatter.space())
                .append(formatter.token(colon))
                .append(
                    formatter.indent(formatter.line().append(else_expression.format(formatter))),
                )
                .group(),
            If(..) => format_if_expression(self, formatter, true),
            Match(keyword, matcher, open, cases, close) => {
                let head = formatter
                    .token(keyword)
                    .append(formatter.space())
                    .append(matcher.format(formatter))
                    .append(formatter.space())
                    .append(formatter.token(open));
                if cases.is_empty() {
                    return head
                        .append(formatter.space())
                        .append(formatter.token(close));
                }
                let cases = cases
                    .iter()
                    .map(|MatchCase(keyword, pattern, guard, expression)| {
                        formatter
                            .token(keyword)
                            .append(formatter.space())
                            .append(pattern.format(formatter))
                            .append(formatter.space())
                            .append(guard.as_ref().map_or_else(
                                Formatter::nil,
                                |(keyword, guard)| {
                                    formatter
                                        .token(keyword)
                                        .append(formatter.space())
                                        .append(guard.format(formatter))
                                        .append(formatter.space())
                                },
                            ))
                            .append(expression.format(formatter))
                    });
                head.append(
                    formatter.indent(
                        formatter
                            .hardline()
                            .append(formatter.join(cases, formatter.hardline())),
                    ),
                )
                .append(formatter.hardline())
                .append(formatter.token(close))
            }
            Function(keyword, parameters, body) => formatter
                .token(keyword)
                .append(formatter.space())
                .append(parameters.format(formatter))
                .append(if parameters.is_some() {
                    formatter.space()
                } else {
                    Formatter::nil()
                })
                .append(body.format(formatter)),
            Unknown { .. } => Formatter::nil(),
        }
    }
}