Struct FunctionBuilder

pub(crate) struct FunctionBuilder {
    pub(crate) arena: TombstoneArena<InstrSeq>,
    pub(crate) ty: Id<Type>,
    pub(crate) entry: Option<Id<InstrSeq>>,
    pub(crate) name: Option<String>,
}

Expand description

Build instances of LocalFunction.

§Example

For micro-examples, see the docs for various FunctionBuilder and InstrSeqBuilder methods.
For a bit more realistic example, see examples/build-wasm-from-scratch.rs.

Fields§

§arena: TombstoneArena<InstrSeq>§ty: Id<Type>§entry: Option<Id<InstrSeq>>§name: Option<String>

Implementations§

§

impl FunctionBuilder

pub fn new( types: &mut ModuleTypes, params: &[ValType], results: &[ValType], ) -> FunctionBuilder

Creates a new, empty function builder.

pub fn name(&mut self, function_name: String) -> &mut FunctionBuilder

Set function name.

pub fn func_body_id(&self) -> Id<InstrSeq>

Get the id of this function’s body’s instruction sequence.

pub fn func_body(&mut self) -> InstrSeqBuilder<'_>

Get a InstrSeqBuilder for building and mutating this function’s body.

pub fn instr_seq(&mut self, id: Id<InstrSeq>) -> InstrSeqBuilder<'_>

Continue building and mutating an existing instruction sequence.

§Example

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

let mut block = builder.dangling_instr_seq(None);
let id = block.id();
// Build up the block some.
block
    .f64_const(1337.0)
    .drop();

// Do some other stuff...
drop(block);

// Use `instr_seq` to get the builder for the block again, and build
// some more things onto it.
let mut block = builder.instr_seq(id);
block
    .i32_const(42)
    .drop();

pub fn dangling_instr_seq( &mut self, ty: impl Into<InstrSeqType>, ) -> InstrSeqBuilder<'_>

Create a new instruction sequence that is unreachable.

It is your responsibility to

make a Instr::Block, Instr::Loop, or Instr::IfElse that uses this instruction sequence, and
append that Instr into a parent instruction sequence via InstrSeqBuilder::instr or InstrSeqBuilder::instr_at

or else this built up instruction sequence will never be used.

§Example

use walrus::ir::*;

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

// Create an empty, dangling instruction sequemce.
let mut seq = builder.dangling_instr_seq(None);
let seq_id = seq.id();

// Do stuff with the sequence...
drop(seq);

// Finally, make our instruction sequence reachable by adding an
// block/loop/if-else instruction that uses it to a reachable instruction
// sequence.
builder
    .func_body()
    .instr(Block { seq: seq_id });

pub fn finish( self, args: Vec<Id<Local>>, funcs: &mut ModuleFunctions, ) -> Id<Function>

Finishes this builder, wrapping it all up and inserting it into the specified Module.

§Example

let mut module = walrus::Module::default();
let mut builder = walrus::FunctionBuilder::new(&mut module.types, &[], &[]);

builder
    .func_body()
    .i32_const(1234)
    .drop();

let function_id = builder.finish(vec![], &mut module.funcs);