Struct SsaVariable 

pub struct SsaVariable<T: Target> {
    id: SsaVarId,
    origin: VariableOrigin,
    version: u32,
    def_site: DefSite,
    var_type: T::Type,
    uses: Vec<UseSite>,
    address_taken: bool,
}

Complete metadata for an SSA variable.

Each SSA variable has exactly one definition and zero or more uses. This structure bundles all metadata needed for analysis, optimization, and code generation.

Invariants

• id.index() equals the variable’s position in SsaFunction::variables (maintained by create_variable and compact_variables)
• Version 0 of arguments/locals is typically the value at function entry
• def_site is None-instruction for phi nodes (definition at block entry)

Construction

Variables are created through SsaFunction::create_variable(), which ensures dense ID allocation, origin registration, and type tracking.

Fields

id: SsaVarId

Dense unique identifier within the owning function. Invariant: id.index() == position in SsaFunction.variables.

origin: VariableOrigin

CIL origin of this variable: method argument, local, or phi node result. Used for rename grouping and debug display.

version: u32

SSA version number for this variable.

For arguments and locals, each assignment creates a new version. Version 0 is the initial value at method entry (argument values, zero-initialized locals). Higher versions correspond to later assignments.

def_site: DefSite

Location in the SSA function where this variable is defined.

• DefSite::instruction(block, idx) for instruction-defined variables
• DefSite::phi(block) for phi node results
• DefSite::entry() for arguments and initialized locals (implicit def)

var_type: T::Type

The type of this variable, resolved during SSA construction.

Inferred from the defining instruction’s result type or the origin’s canonical type. T::unknown_type() if type inference is pending.

uses: Vec<UseSite>

All use sites where this variable is referenced as an operand.

Populated during SSA construction by crate::ir::function::SsaFunction::recompute_uses. Enables dead code elimination (empty uses = dead) and use-based analyses.

address_taken: bool

Whether this variable’s address has been taken via ldarga/ldloca.

Address-taken variables may be modified through pointers, making them ineligible for copy propagation, dead store elimination, and other optimizations that assume single-assignment immutability.

Implementations

impl<T: Target> SsaVariable<T>

pub fn new( id: SsaVarId, origin: VariableOrigin, version: u32, def_site: DefSite, var_type: T::Type, ) -> Self

Creates a new SSA variable with a pre-allocated ID and type.

Note: prefer creating variables through SsaFunction::create_variable (in the host crate), which ensures dense ID allocation via FunctionVarAllocator. This constructor is pub only because the host crate’s SsaFunction lives outside analyssa and needs to call it.

Arguments

• id - The dense variable ID from FunctionVarAllocator
• origin - Where this variable came from in the host
• version - SSA version number
• def_site - Where this variable is defined
• var_type - The type of this variable

pub const fn id(&self) -> SsaVarId

Returns the variable’s unique identifier.

pub const fn origin(&self) -> VariableOrigin

Returns where this variable originated in the CIL.

pub const fn version(&self) -> u32

Returns the SSA version number.

pub const fn def_site(&self) -> DefSite

Returns where this variable is defined.

pub fn var_type(&self) -> &T::Type

Returns the type of this variable.

Returns the host’s “unknown” type if type inference hasn’t been performed.

pub fn set_def_site(&mut self, site: DefSite)

Updates where this variable is defined.

pub fn set_type(&mut self, var_type: T::Type)

Sets the type of this variable.

This is typically called during type inference or when resolving phi node types.

pub fn has_known_type(&self) -> bool

Returns true if the variable’s type is known (not the host’s “unknown” type).

pub fn uses(&self) -> &[UseSite]

Returns all use sites for this variable.

pub const fn is_address_taken(&self) -> bool

Returns true if this variable’s address has been taken.

pub fn is_dead(&self) -> bool

Returns true if this variable has no uses (dead).

pub fn use_count(&self) -> usize

Returns the number of uses for this variable.

pub fn retain_uses<F>(&mut self, keep: F)

where F: FnMut(&UseSite) -> bool,

Drops the use sites for which keep returns false.

Lets a caller that knows exactly which uses it rewrote keep this list exact without a whole-function rescan — the difference between an O(1) index update and an O(function) walk per replacement.

pub fn add_use(&mut self, use_site: UseSite)

Adds a use site for this variable.

pub fn clear_uses(&mut self)

Clears all use sites for this variable.

This is used when recomputing use information after SSA transformations that may have invalidated the use tracking.

pub fn set_address_taken(&mut self)

Marks this variable as having its address taken.

pub fn set_origin(&mut self, origin: VariableOrigin)

Sets the origin of this variable.

This is used during local variable optimization to update indices after unused locals are removed.

pub fn set_id(&mut self, id: SsaVarId)

Sets the variable’s ID.

Used during variable compaction to reassign dense IDs.

Trait Implementations

impl<T: Target> Clone for SsaVariable<T>

fn clone_from(&mut self, source: &Self)

Overwrites self from source, reusing this variable’s existing uses allocation.

Hand-written for the same reason as SsaFunction::clone_from: the derived Clone supplies only the default clone_from (*self = source.clone()), which drops and reallocates the uses vector on every call. Because Vec::clone_from calls clone_from element-wise, specializing here is what lets a whole-function snapshot reuse every per-variable use-list buffer instead of stopping at the variables spine. Functions carry one such vector per SSA variable, so this is the largest count of small allocations the optimization pipeline’s repeated rollback snapshots would otherwise re-make.

The exhaustive destructure is deliberate: adding a field makes this fail to compile rather than silently producing a stale-in-one-field clone.

fn clone(&self) -> Self

Returns a duplicate of the value.

impl<T: Debug + Target> Debug for SsaVariable<T>

where T::Type: Debug,

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

Formats the value using the given formatter.

impl<'de, T: Target> Deserialize<'de> for SsaVariable<T>

where T::Type: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Target> Display for SsaVariable<T>

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

Formats the value using the given formatter.

impl<T: Target> Serialize for SsaVariable<T>

where T::Type: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.