Struct CompilationUnit 

pub struct CompilationUnit<'src> { /* private fields */ }

A unified compilation unit that owns all artifacts from source to machine code.

The compilation unit progresses through phases:

1. New: Just source files
2. Parsed: ASTs and interner from parsing
3. Lowered: RIR (untyped intermediate representation)
4. Analyzed: AIR (typed IR) and CFGs for all functions

Each phase builds on the previous one. The unit validates that phases are run in order - you can’t analyze before parsing.

Thread Safety

The compilation unit uses ThreadedRodeo for string interning, which is thread-safe. Parallel operations (like per-function CFG construction) can safely share the interner.

Implementations

impl<'src> CompilationUnit<'src>

pub fn new(sources: Vec<SourceFile<'src>>, options: CompileOptions) -> Self

Create a new compilation unit from source files.

This initializes the unit with source files but does not run any compilation phases. Call parse(), lower(), and analyze() to progress through compilation.

Arguments

• sources - Source files to compile
• options - Compilation options (target, optimization, etc.)

pub fn parse(&mut self) -> MultiErrorResult<()>

Parse all source files.

This runs lexing and parsing on each source file, producing ASTs. The ASTs are then merged into a single program, detecting any duplicate symbol definitions.

Errors

Returns errors if:

• Any file fails to lex or parse
• Duplicate function, struct, or enum definitions are found

pub fn lower(&mut self) -> MultiErrorResult<()>

Generate untyped intermediate representation (RIR).

This transforms the merged AST into RIR, which is a more uniform representation suitable for semantic analysis.

Panics

Panics if called before parse().

pub fn analyze(&mut self) -> MultiErrorResult<()>

Perform semantic analysis and build control flow graphs.

This runs type checking, symbol resolution, and other semantic checks, then builds CFGs for each function. Optimizations are applied based on the configured optimization level.

Panics

Panics if called before lower().

pub fn compile(&self) -> MultiErrorResult<CompileOutput>

Generate machine code and link into an executable.

This is the final compilation phase. It generates machine code for all functions and links them into an executable binary.

Panics

Panics if called before analyze().

pub fn run_frontend(&mut self) -> MultiErrorResult<()>

Run all frontend phases (parse, lower, analyze).

This is a convenience method that runs the complete frontend pipeline. Equivalent to calling parse(), lower(), and analyze() in sequence.

pub fn run_all(&mut self) -> MultiErrorResult<CompileOutput>

Run all phases and produce a compiled binary.

This is a convenience method that runs the complete compilation pipeline. Equivalent to calling run_frontend() followed by compile().

pub fn is_parsed(&self) -> bool

Check if parsing has been completed.

pub fn is_lowered(&self) -> bool

Check if RIR generation has been completed.

pub fn is_analyzed(&self) -> bool

Check if semantic analysis has been completed.

pub fn options(&self) -> &CompileOptions

Get the compilation options.

pub fn ast(&self) -> &Ast

Get the merged AST (after parsing).

Panics

Panics if called before parse().

pub fn interner(&self) -> &ThreadedRodeo

Get the string interner.

Panics

Panics if called before parse().

pub fn rir(&self) -> &Rir

Get the RIR (after lowering).

Panics

Panics if called before lower().

pub fn functions(&self) -> &[FunctionWithCfg]

Get the analyzed functions with CFGs (after analysis).

Panics

Panics if called before analyze().

pub fn type_pool(&self) -> &TypeInternPool

Get the type pool (after analysis).

Panics

Panics if called before analyze().

pub fn strings(&self) -> &[String]

Get string literals (after analysis).

Panics

Panics if called before analyze().

pub fn warnings(&self) -> &[CompileWarning]

Get all warnings collected during compilation.

pub fn file_paths(&self) -> &HashMap<FileId, String>

Get the file paths map.

pub fn take_interner(&mut self) -> ThreadedRodeo

Take the interner out of the compilation unit.

This is useful when you need ownership of the interner (e.g., for code generation).

Panics

Panics if called before parse() or if the interner has already been taken.

pub fn take_functions(&mut self) -> Vec<FunctionWithCfg>

Take the functions out of the compilation unit.

Panics

Panics if called before analyze() or if the functions have already been taken.

pub fn take_type_pool(&mut self) -> TypeInternPool

Take the type pool out of the compilation unit.

Panics

Panics if called before analyze() or if the type pool has already been taken.

pub fn take_strings(&mut self) -> Vec<String>

Take the strings out of the compilation unit.

Panics

Panics if called before analyze() or if the strings have already been taken.

pub fn take_warnings(&mut self) -> Vec<CompileWarning>

Take the warnings out of the compilation unit.

Trait Implementations

impl<'src> Debug for CompilationUnit<'src>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.