Struct Pipeline 

pub struct Pipeline { /* private fields */ }

A composable sequence of IR passes.

Passes run in order; the output of each feeds the next. After all passes, call Pipeline::emit to run a Backend on the final module, or Pipeline::run to get the transformed module directly.

Example

use formalang::{compile_to_ir, Backend, Pipeline};
use formalang::ir::{IrModule, DeadCodeEliminationPass, ConstantFoldingPass};


let source = "pub struct User { name: String }";
let ir = compile_to_ir(source).unwrap();

let result = Pipeline::new()
    .pass(DeadCodeEliminationPass::new())
    .pass(ConstantFoldingPass::new())
    .emit(ir, &MyBackend)
    .unwrap();

Implementations

impl Pipeline

pub fn new() -> Pipeline

Create an empty pipeline with no passes.

pub fn pass(self, p: impl IrPass + 'static) -> Pipeline

Append a pass and return self for chaining.

pub fn for_codegen() -> Pipeline

Pre-built pipeline for backends emitting integer-indexed code (formawasm, eventual JVM/LLVM): runs MonomorphisePass, ResolveReferencesPass, ClosureConversionPass, then DeadCodeEliminationPass. Pure-source-printing backends should use Self::new and pick passes individually.

Example

use formalang::{compile_to_ir, Pipeline};

let module = compile_to_ir("pub fn id(x: I32) -> I32 { x }").unwrap();
let _ = Pipeline::for_codegen().run(module).unwrap();

pub fn run(&mut self, module: IrModule) -> Result<IrModule, Vec<CompilerError>>

Run all passes in order, returning the transformed module.

Errors

Returns the errors from the first failing pass.

pub fn emit<B>( &mut self, module: IrModule, backend: &B, ) -> Result<<B as Backend>::Output, PipelineError<<B as Backend>::Error>>

where B: Backend,

Run all passes then emit with the given backend.

Errors

Returns PipelineError::PassErrors if any pass fails, or PipelineError::BackendError if the backend fails.

Trait Implementations

impl Debug for Pipeline

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

Formats the value using the given formatter.

impl Default for Pipeline

fn default() -> Pipeline

Returns the “default value” for a type.