84 lines
2.8 KiB
Rust
84 lines
2.8 KiB
Rust
pub mod token;
|
|
pub mod lexer;
|
|
pub mod ast;
|
|
pub mod parser;
|
|
pub mod types;
|
|
pub mod symbols;
|
|
pub mod collector;
|
|
pub mod resolver;
|
|
pub mod resolve;
|
|
pub mod typecheck;
|
|
pub mod lowering;
|
|
pub mod contracts;
|
|
|
|
pub use collector::SymbolCollector;
|
|
pub use lexer::Lexer;
|
|
pub use lowering::Lowerer;
|
|
pub use resolver::{ModuleProvider, Resolver};
|
|
pub use symbols::{ModuleSymbols, Namespace, Symbol, SymbolKind, SymbolTable, Visibility};
|
|
pub use token::{Token, TokenKind};
|
|
pub use typecheck::TypeChecker;
|
|
|
|
use crate::common::diagnostics::DiagnosticBundle;
|
|
use crate::common::files::FileManager;
|
|
use crate::frontends::Frontend;
|
|
use crate::ir_vm;
|
|
use crate::lowering::core_to_vm;
|
|
use prometeu_analysis::NameInterner;
|
|
use std::path::Path;
|
|
|
|
pub struct PbsFrontend;
|
|
|
|
impl Frontend for PbsFrontend {
|
|
fn language(&self) -> &'static str {
|
|
"pbs"
|
|
}
|
|
|
|
fn compile_to_ir(
|
|
&self,
|
|
entry: &Path,
|
|
file_manager: &mut FileManager,
|
|
) -> Result<ir_vm::Module, DiagnosticBundle> {
|
|
let source = std::fs::read_to_string(entry).map_err(|e| {
|
|
DiagnosticBundle::error(format!("Failed to read file: {}", e), None)
|
|
})?;
|
|
let file_id = file_manager.add(entry.to_path_buf(), source.clone());
|
|
|
|
let mut interner = NameInterner::new();
|
|
let mut parser = parser::Parser::new(&source, file_id, &mut interner);
|
|
let parsed = parser.parse_file()?;
|
|
|
|
let mut collector = SymbolCollector::new(&interner);
|
|
let (type_symbols, value_symbols) =
|
|
collector.collect(&parsed.arena, parsed.root)?;
|
|
let mut module_symbols = ModuleSymbols { type_symbols, value_symbols };
|
|
|
|
struct EmptyProvider;
|
|
impl ModuleProvider for EmptyProvider {
|
|
fn get_module_symbols(&self, _path: &str) -> Option<&ModuleSymbols> { None }
|
|
}
|
|
|
|
let mut resolver = Resolver::new(&module_symbols, &EmptyProvider, &interner);
|
|
resolver.resolve(&parsed.arena, parsed.root)?;
|
|
let imported_symbols = resolver.imported_symbols;
|
|
|
|
let mut typechecker = TypeChecker::new(&mut module_symbols, &imported_symbols, &EmptyProvider, &interner);
|
|
typechecker.check(&parsed.arena, parsed.root)?;
|
|
|
|
// Lower to Core IR
|
|
let lowerer = Lowerer::new(&parsed.arena, &module_symbols, &imported_symbols, &interner);
|
|
let module_name = entry.file_stem().unwrap().to_string_lossy();
|
|
let core_program = lowerer.lower_file(parsed.root, &module_name)?;
|
|
|
|
// Validate Core IR Invariants
|
|
crate::ir_core::validate_program(&core_program).map_err(|e| {
|
|
DiagnosticBundle::error(format!("Core IR Invariant Violation: {}", e), None)
|
|
})?;
|
|
|
|
// Lower Core IR to VM IR
|
|
core_to_vm::lower_program(&core_program).map_err(|e| {
|
|
DiagnosticBundle::error(format!("Lowering error: {}", e), None)
|
|
})
|
|
}
|
|
}
|