1use crate::{AstSnapshots, CompilerOptions};
22
23pub use leo_ast::Ast;
24use leo_ast::{NetworkName, Stub};
25use leo_errors::{CompilerError, Handler, Result};
26use leo_passes::*;
27use leo_span::{Symbol, source_map::FileName, with_session_globals};
28
29use std::{
30 ffi::OsStr,
31 fs,
32 path::{Path, PathBuf},
33};
34
35use indexmap::{IndexMap, IndexSet};
36use walkdir::WalkDir;
37
38pub struct Compiler {
40 output_directory: PathBuf,
42 pub program_name: Option<String>,
44 compiler_options: CompilerOptions,
46 state: CompilerState,
48 import_stubs: IndexMap<Symbol, Stub>,
50 pub statements_before_dce: u32,
52 pub statements_after_dce: u32,
54}
55
56impl Compiler {
57 pub fn parse(&mut self, source: &str, filename: FileName, modules: &[(&str, FileName)]) -> Result<()> {
58 let source_file = with_session_globals(|s| s.source_map.new_source(source, filename));
60
61 let modules = modules
63 .iter()
64 .map(|(source, filename)| with_session_globals(|s| s.source_map.new_source(source, filename.clone())))
65 .collect::<Vec<_>>();
66
67 self.state.ast = leo_parser::parse_ast(
69 self.state.handler.clone(),
70 &self.state.node_builder,
71 &source_file,
72 &modules,
73 self.state.network,
74 )?;
75
76 let program_scope = self.state.ast.ast.program_scopes.values().next().unwrap();
79 if self.program_name.is_none() {
80 self.program_name = Some(program_scope.program_id.name.to_string());
81 } else if self.program_name != Some(program_scope.program_id.name.to_string()) {
82 return Err(CompilerError::program_name_should_match_file_name(
83 program_scope.program_id.name,
84 self.program_name.as_ref().unwrap(),
85 program_scope.program_id.name.span,
86 )
87 .into());
88 }
89
90 if self.compiler_options.initial_ast {
91 self.write_ast_to_json("initial.json")?;
92 self.write_ast("initial.ast")?;
93 }
94
95 Ok(())
96 }
97
98 #[allow(clippy::too_many_arguments)]
100 pub fn new(
101 expected_program_name: Option<String>,
102 is_test: bool,
103 handler: Handler,
104 output_directory: PathBuf,
105 compiler_options: Option<CompilerOptions>,
106 import_stubs: IndexMap<Symbol, Stub>,
107 network: NetworkName,
108 ) -> Self {
109 Self {
110 state: CompilerState { handler, is_test, network, ..Default::default() },
111 output_directory,
112 program_name: expected_program_name,
113 compiler_options: compiler_options.unwrap_or_default(),
114 import_stubs,
115 statements_before_dce: 0,
116 statements_after_dce: 0,
117 }
118 }
119
120 fn do_pass<P: Pass>(&mut self, input: P::Input) -> Result<P::Output> {
121 let output = P::do_pass(input, &mut self.state)?;
122
123 let write = match &self.compiler_options.ast_snapshots {
124 AstSnapshots::All => true,
125 AstSnapshots::Some(passes) => passes.contains(P::NAME),
126 };
127
128 if write {
129 self.write_ast_to_json(&format!("{}.json", P::NAME))?;
130 self.write_ast(&format!("{}.ast", P::NAME))?;
131 }
132
133 Ok(output)
134 }
135
136 pub fn intermediate_passes(&mut self) -> Result<()> {
138 let type_checking_config = TypeCheckingInput::new(self.state.network);
139
140 self.do_pass::<PathResolution>(())?;
141
142 self.do_pass::<SymbolTableCreation>(())?;
143
144 self.do_pass::<TypeChecking>(type_checking_config.clone())?;
145
146 self.do_pass::<ProcessingAsync>(type_checking_config.clone())?;
147
148 self.do_pass::<StaticAnalyzing>(())?;
149
150 self.do_pass::<ConstPropUnrollAndMorphing>(type_checking_config.clone())?;
151
152 self.do_pass::<OptionLowering>(type_checking_config)?;
153
154 self.do_pass::<ProcessingScript>(())?;
155
156 self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: true })?;
157
158 self.do_pass::<Destructuring>(())?;
159
160 self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: false })?;
161
162 self.do_pass::<WriteTransforming>(())?;
163
164 self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: false })?;
165
166 self.do_pass::<Flattening>(())?;
167
168 self.do_pass::<FunctionInlining>(())?;
169
170 self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: true })?;
173
174 self.do_pass::<CommonSubexpressionEliminating>(())?;
175
176 let output = self.do_pass::<DeadCodeEliminating>(())?;
177 self.statements_before_dce = output.statements_before;
178 self.statements_after_dce = output.statements_after;
179
180 Ok(())
181 }
182
183 pub fn compile(&mut self, source: &str, filename: FileName, modules: &Vec<(&str, FileName)>) -> Result<String> {
198 self.parse(source, filename, modules)?;
200 self.add_import_stubs()?;
202 self.intermediate_passes()?;
204 let bytecode = CodeGenerating::do_pass((), &mut self.state)?;
206 Ok(bytecode)
207 }
208
209 pub fn compile_from_directory(
230 &mut self,
231 entry_file_path: impl AsRef<Path>,
232 source_directory: impl AsRef<Path>,
233 ) -> Result<String> {
234 let source = fs::read_to_string(&entry_file_path)
236 .map_err(|e| CompilerError::file_read_error(entry_file_path.as_ref().display().to_string(), e))?;
237
238 let files = WalkDir::new(source_directory)
240 .into_iter()
241 .filter_map(Result::ok)
242 .filter(|e| {
243 e.file_type().is_file()
244 && e.path() != entry_file_path.as_ref()
245 && e.path().extension() == Some(OsStr::new("leo"))
246 })
247 .collect::<Vec<_>>();
248
249 let mut module_sources = Vec::new(); let mut modules = Vec::new(); for file in &files {
254 let source = fs::read_to_string(file.path())
255 .map_err(|e| CompilerError::file_read_error(file.path().display().to_string(), e))?;
256 module_sources.push(source); }
258
259 for (i, file) in files.iter().enumerate() {
261 let source = &module_sources[i]; modules.push((&source[..], FileName::Real(file.path().into())));
263 }
264
265 self.compile(&source, FileName::Real(entry_file_path.as_ref().into()), &modules)
267 }
268
269 fn write_ast_to_json(&self, file_suffix: &str) -> Result<()> {
271 if self.compiler_options.ast_spans_enabled {
273 self.state.ast.to_json_file(
274 self.output_directory.clone(),
275 &format!("{}.{file_suffix}", self.program_name.as_ref().unwrap()),
276 )?;
277 } else {
278 self.state.ast.to_json_file_without_keys(
279 self.output_directory.clone(),
280 &format!("{}.{file_suffix}", self.program_name.as_ref().unwrap()),
281 &["_span", "span"],
282 )?;
283 }
284 Ok(())
285 }
286
287 fn write_ast(&self, file_suffix: &str) -> Result<()> {
289 let filename = format!("{}.{file_suffix}", self.program_name.as_ref().unwrap());
290 let full_filename = self.output_directory.join(&filename);
291 let contents = self.state.ast.ast.to_string();
292 fs::write(&full_filename, contents).map_err(|e| CompilerError::failed_ast_file(full_filename.display(), e))?;
293 Ok(())
294 }
295
296 pub fn add_import_stubs(&mut self) -> Result<()> {
299 let mut explored = IndexSet::<Symbol>::new();
300 let mut to_explore: Vec<Symbol> = self.state.ast.ast.imports.keys().cloned().collect();
301
302 while let Some(import) = to_explore.pop() {
303 explored.insert(import);
304 if let Some(stub) = self.import_stubs.get(&import) {
305 for new_import_id in stub.imports.iter() {
306 if !explored.contains(&new_import_id.name.name) {
307 to_explore.push(new_import_id.name.name);
308 }
309 }
310 } else {
311 return Err(CompilerError::imported_program_not_found(
312 self.program_name.as_ref().unwrap(),
313 import,
314 self.state.ast.ast.imports[&import].1,
315 )
316 .into());
317 }
318 }
319
320 self.state.ast.ast.stubs = self
323 .import_stubs
324 .iter()
325 .filter(|(symbol, _stub)| explored.contains(*symbol))
326 .map(|(symbol, stub)| (*symbol, stub.clone()))
327 .collect();
328 Ok(())
329 }
330}