mirascript-core 0.1.105

Compiler and bytecode definitions for the MiraScript language
Documentation
use std::ops::Deref;

use crate::{
    lexer::{NumberInfo, StringFragment, Token, TokenKind},
    parser::Expression,
};

use super::{FormatDoc, FormatManager, Formattable};

impl Formattable for Token<'_> {
    fn format(&self, formatter: &FormatManager) -> FormatDoc {
        formatter.token(self)
    }
}

fn grouped_digits(s: &str, group_size: usize, min_size: usize, right_to_left: bool) -> String {
    if group_size == 0 || s.len() <= group_size || (min_size != 0 && s.len() < min_size) {
        return s.to_owned();
    }
    let mut output = String::with_capacity(s.len() + s.len() / group_size);
    for (index, byte) in s.bytes().enumerate() {
        let insert = if right_to_left {
            index > 0 && (s.len() - index).is_multiple_of(group_size)
        } else {
            index > 0 && index.is_multiple_of(group_size)
        };
        if insert {
            output.push('_');
        }
        output.push(byte as char);
    }
    output
}

fn normalized_number(value: f64, info: &NumberInfo<'_>) -> String {
    match info {
        NumberInfo::Invalid => format!("{value:e}"),
        NumberInfo::Decimal(source) => {
            let source = source.replace('_', "");
            let (mantissa, exponent) = source
                .find(['e', 'E'])
                .map_or((source.as_str(), None), |index| {
                    (&source[..index], Some(&source[index + 1..]))
                });
            let (integer, fraction) = mantissa.find('.').map_or((mantissa, None), |index| {
                (&mantissa[..index], Some(&mantissa[index + 1..]))
            });
            let mut output = grouped_digits(integer, 3, 5, true);
            if let Some(fraction) = fraction.filter(|fraction| !fraction.is_empty()) {
                output.push('.');
                output.push_str(&grouped_digits(fraction, 3, 5, false));
            }
            if let Some(exponent) = exponent.filter(|exponent| !exponent.is_empty()) {
                output.push('e');
                output.push_str(exponent);
            }
            output
        }
        NumberInfo::Hexadecimal(value) => {
            format!("0x{}", grouped_digits(&format!("{value:X}"), 4, 0, true))
        }
        NumberInfo::Octal(value) => {
            format!("0o{}", grouped_digits(&format!("{value:o}"), 6, 0, true))
        }
        NumberInfo::Binary(value) => {
            format!("0b{}", grouped_digits(&format!("{value:b}"), 8, 0, true))
        }
    }
}

impl FormatManager<'_> {
    pub fn string_token(&self, token: &Token<'_>, expressions: &[Expression<'_>]) -> FormatDoc {
        let (TokenKind::String(_, info) | TokenKind::InterpolatedString(_, info)) = &token.kind
        else {
            unreachable!();
        };
        let mut docs = vec![self.leading_trivia(&token.leading_trivia)];
        let dollars = "$".repeat(info.ats.max(1));
        if let Some(quote) = info.quote {
            docs.push(self.text("@".repeat(info.ats)));
            docs.push(self.text(quote.to_string()));
        }
        let mut expressions = expressions.iter();
        let mut line_indent = 0;
        let mut at_line_start = true;
        for fragment in info.content.iter() {
            match fragment {
                StringFragment::Literal(text) => {
                    docs.push(self.source_text(text));
                    update_line_indent(
                        text,
                        self.options.tab_size,
                        &mut line_indent,
                        &mut at_line_start,
                    );
                }
                StringFragment::EscapedChar(_, text) => {
                    docs.push(self.text(format!(
                        "\\{}{}",
                        &text[..1],
                        text[1..].to_ascii_uppercase()
                    )));
                }
                StringFragment::Interpolation(_, _, format, surround) => {
                    docs.push(self.text(dollars.clone()));
                    if let Some((start, _)) = surround.as_deref() {
                        docs.push(self.text(start.to_string()));
                    }
                    if let Some(expression) = expressions.next() {
                        docs.push(expression.format(self).nest(line_indent as isize));
                    }
                    if !format.is_empty() {
                        docs.push(self.text(format!(":{format}")));
                    }
                    if let Some((_, end)) = surround.as_deref() {
                        docs.push(self.text(end.to_string()));
                    }
                }
                StringFragment::InvalidEscapedChar(_, _)
                | StringFragment::EndOfString
                | StringFragment::EndOfFile => {}
            }
        }
        if let Some(quote) = info.quote {
            docs.push(self.text(quote.to_string()));
            docs.push(self.text("@".repeat(info.ats)));
        }
        docs.push(self.tailing_trivia(&token.tailing_trivia));
        self.concat(docs)
    }

    pub fn token_body(&self, kind: &TokenKind<'_>) -> FormatDoc {
        let text = match kind {
            TokenKind::String(_, _) | TokenKind::InterpolatedString(_, _) => unreachable!(),
            TokenKind::Identifier(value) => (*value).to_owned(),
            TokenKind::Ordinal(value) => value.to_string(),
            TokenKind::Number(value, info) => normalized_number(*value, info),
            TokenKind::Operator(operator) => operator.to_string(),
            TokenKind::Keyword(keyword) => {
                let keyword: &str = keyword.into();
                keyword.to_owned()
            }
            TokenKind::Eof | TokenKind::Empty | TokenKind::Unknown { .. } => String::new(),
        };
        self.text(text)
    }

    pub fn token(&self, token: &Token<'_>) -> FormatDoc {
        if matches!(
            token.kind,
            TokenKind::String(_, _) | TokenKind::InterpolatedString(_, _)
        ) {
            return self.string_token(token, &[]);
        }
        self.leading_trivia(&token.leading_trivia)
            .append(self.token_body(&token.kind))
            .append(self.tailing_trivia(&token.tailing_trivia))
    }

    pub fn token_without_leading(&self, token: &Token<'_>) -> FormatDoc {
        self.token_body(&token.kind)
            .append(self.tailing_trivia(&token.tailing_trivia))
    }

    pub fn token_or<'s, T, F>(&self, token: Option<T>, fallback: F) -> FormatDoc
    where
        T: Deref<Target = Token<'s>>,
        F: Into<TokenKind<'s>>,
    {
        token.as_deref().map_or_else(
            || self.token_body(&fallback.into()),
            |token| self.token(token),
        )
    }
}

fn update_line_indent(
    text: &str,
    tab_size: usize,
    line_indent: &mut usize,
    at_line_start: &mut bool,
) {
    for character in text.chars() {
        match character {
            '\r' | '\n' => {
                *line_indent = 0;
                *at_line_start = true;
            }
            ' ' if *at_line_start => *line_indent += 1,
            '\t' if *at_line_start => *line_indent += tab_size,
            _ => *at_line_start = false,
        }
    }
}