Skip to main content

mirascript_core/compile/
mod.rs

1use winnow::stream::{Location, Stream};
2
3use crate::parser::{self, AstWalker};
4use crate::{
5    Script,
6    config::{CompileConfig, InputMode},
7};
8use crate::{diagnostic::DiagnosticsCollector, emitter};
9use crate::{
10    diagnostic::SerializedDiagnostics,
11    lexer::{self},
12};
13use crate::{
14    diagnostic::{DiagnosticCode, SourceRange},
15    lexer::Token,
16};
17
18mod recover_token;
19
20pub type CompileResult = (Option<Vec<u8>>, SerializedDiagnostics);
21
22pub struct Compiler<'s, 'c> {
23    pub script: &'s str,
24    pub config: &'c CompileConfig,
25    pub diagnostics_collector: DiagnosticsCollector<'s, 'c>,
26}
27
28impl<'s, 'c: 's> Compiler<'s, 'c> {
29    pub fn new(script: &'s str, config: &'c CompileConfig) -> Self {
30        Self {
31            script,
32            config,
33            diagnostics_collector: DiagnosticsCollector::new(config, script),
34        }
35    }
36
37    pub fn lex(&mut self) -> Option<Box<[Token<'s>]>> {
38        let current_lexer = if self.config.input_mode == InputMode::Script {
39            lexer::lex
40        } else {
41            lexer::lex_string
42        };
43        let mut input = lexer::to_input(self.script, self.config);
44        let Ok(tokens) = current_lexer(&mut input) else {
45            let remaining = input.peek_finish();
46            let range = if remaining.is_empty() {
47                SourceRange {
48                    start: 0,
49                    end: input.len(),
50                }
51            } else {
52                SourceRange {
53                    start: input.current_token_start(),
54                    end: input.len(),
55                }
56            };
57            self.diagnostics_collector
58                .push(DiagnosticCode::LexerError, range);
59            return None;
60        };
61
62        // Try to recover from lexing errors
63        Some(
64            tokens
65                .into_iter()
66                .filter_map(|t| recover_token::recover_token(t, &mut self.diagnostics_collector))
67                .collect(),
68        )
69    }
70
71    pub fn parse<'t>(&mut self, tokens: &'t [Token<'t>]) -> Option<Script<'t>> {
72        assert!(!tokens.is_empty(), "Cannot parse an empty token list");
73
74        // Parsing
75        let mut stream = parser::to_input(tokens);
76        let Ok(mut script) = parser::parse(&mut stream) else {
77            let remaining = stream.peek_finish();
78            let range = if remaining.is_empty() {
79                tokens.last().unwrap().range.clone()
80            } else {
81                SourceRange {
82                    start: remaining.first().unwrap().range.start,
83                    end: remaining.last().unwrap().range.end,
84                }
85            };
86            self.diagnostics_collector
87                .push(DiagnosticCode::ParserError, range);
88            return None;
89        };
90
91        // collect and recover from parsing errors
92        script.collect_diagnostics(&mut self.diagnostics_collector);
93        Some(script)
94    }
95
96    pub fn emit(&mut self, script: &Script<'s>) -> Option<Vec<u8>> {
97        if self.config.diagnostic_hint {
98            crate::control_flow::analyze(script, &mut self.diagnostics_collector);
99        }
100        // Emitting
101        let bytecode = emitter::emit(script, &mut self.diagnostics_collector);
102
103        let has_error = self
104            .diagnostics_collector
105            .iter()
106            .any(|d| d.error.is_error());
107
108        if has_error {
109            return None;
110        }
111
112        Some(bytecode)
113    }
114
115    pub fn encode_diagnostics(&self) -> SerializedDiagnostics {
116        self.diagnostics_collector.encode()
117    }
118
119    pub fn compile(input: &str, config: &CompileConfig) -> CompileResult {
120        let mut compiler = Compiler::new(input, config);
121        let Some(tokens) = compiler.lex() else {
122            return (None, compiler.encode_diagnostics());
123        };
124        let Some(script) = compiler.parse(&tokens) else {
125            return (None, compiler.encode_diagnostics());
126        };
127        let Some(chunk) = compiler.emit(&script) else {
128            return (None, compiler.encode_diagnostics());
129        };
130        (Some(chunk), compiler.encode_diagnostics())
131    }
132}