mirascript_core/compile/
mod.rs1use 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 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 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 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 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}