Struct Lowerer 

pub struct Lowerer<'gcx> {
    pub struct_storage_base_slots: FxHashMap<VariableId, u64>,
    pub struct_field_offsets: FxHashMap<(StructId, usize), u64>,
    pub struct_field_memory_offsets: FxHashMap<(StructId, usize), u64>,
    /* private fields */
}

Lowering context for converting HIR to MIR.

Fields

struct_storage_base_slots: FxHashMap<VariableId, u64>

Mapping from struct state variable ID to base storage slot.

struct_field_offsets: FxHashMap<(StructId, usize), u64>

Cached struct field slot offsets: (struct_type_id, field_index) -> slot offset from base.

struct_field_memory_offsets: FxHashMap<(StructId, usize), u64>

Cached struct field memory offsets: (struct_type_id, field_index) -> byte offset from base.

Implementations

impl<'gcx> Lowerer<'gcx>

pub fn get_struct_field_slot_offset( &mut self, struct_id: StructId, field_index: usize, ) -> u64

Gets the storage slot offset for a struct field.

pub fn calculate_memory_words_for_ty(&self, ty: Ty<'gcx>) -> u64

Calculates the number of 32-byte memory words needed for a type (flattened for structs).

pub fn get_struct_field_memory_offset( &mut self, struct_id: StructId, field_index: usize, ) -> u64

Gets the memory byte offset for a struct field.

pub fn copy_storage_to_memory( &mut self, builder: &mut FunctionBuilder<'_>, struct_id: StructId, base_slot: u64, mem_ptr: ValueId, mem_offset: u64, ) -> u64

Recursively copies a struct from storage to memory. Handles nested structs by flattening them into contiguous memory. Returns the next memory offset after all fields are copied.

pub fn copy_memory_to_storage( &mut self, builder: &mut FunctionBuilder<'_>, struct_id: StructId, base_slot: u64, mem_ptr: ValueId, mem_offset: u64, ) -> u64

Recursively copies a struct from memory to storage. Handles nested structs by reading from flattened memory layout. Returns the next memory offset after all fields are read.

impl<'gcx> Lowerer<'gcx>

pub fn new(gcx: Gcx<'gcx>, name: Ident) -> Self

Creates a new lowerer.

pub fn push_loop(&mut self, ctx: LoopContext)

Pushes a loop context onto the stack.

pub fn pop_loop(&mut self)

Pops a loop context from the stack.

pub fn current_loop(&self) -> Option<&LoopContext>

Gets the current loop context, if any.

pub fn alloc_local_memory(&mut self, var_id: VariableId) -> u64

Allocates a memory slot for a local variable. Returns the memory offset.

pub fn get_local_memory_offset(&self, var_id: &VariableId) -> Option<u64>

Gets the memory offset for a local variable, if it’s stored in memory.

pub fn local_memory_addr( &self, builder: &mut FunctionBuilder<'_>, offset: u64, ) -> ValueId

Returns the address for a local memory slot in the current lowering context.

pub fn immutable_scratch_addr(offset: u32) -> u64

Returns the constructor scratch address for an immutable word.

pub fn store_immutable_value( &self, builder: &mut FunctionBuilder<'_>, offset: u32, value: ValueId, )

Stages an immutable word in constructor memory.

pub fn load_immutable_value( &self, builder: &mut FunctionBuilder<'_>, offset: u32, ) -> ValueId

Loads an immutable word.

Runtime code reads a PUSH32 placeholder that the constructor patches with the staged value before returning the runtime code. The running constructor’s own placeholders are never patched, so constructor-context reads load the staged scratch word instead.

pub fn register_contract_bytecode( &mut self, contract_id: ContractId, bytecode: Vec<u8>, )

Registers a contract’s bytecode for use in new expressions.

pub fn get_contract_bytecode( &self, contract_id: ContractId, ) -> Option<&(Vec<u8>, usize)>

Gets the bytecode for a contract, if registered.

pub fn lower_contract(&mut self, contract_id: ContractId)

Lowers a contract to MIR.

pub fn finish(self) -> Module

Returns the completed module.

pub fn is_var_assigned(&self, var_id: &VariableId) -> bool

Returns true if a variable is assigned after declaration.

pub fn has_external_call(&self, expr: &Expr<'_>) -> bool

Checks if an expression contains an external call. External calls write their return data to shared memory at offset 0, so variables initialized from them must be stored in memory to preserve the value across subsequent calls.