Enum LocalValueId 

#[non_exhaustive]
pub enum LocalValueId {
    Literal(LiteralId),
    Bytes(BytesId),
    Instruction(LocalInsnId),
    BasicBlock(LocalBlockId),
    BlockParam(LocalParamId),
    Varnode(VarnodeId),
    Temp(LocalTempId),
    Function(FunctionId),
    Poison(PoisonId),
}

The body-local twin of ValueId: the form an in-body operand holds once storage is localized (stage 6a, ruling 2).

It mirrors ValueId variant-for-variant, but its arena arms (Instruction/BasicBlock/BlockParam) carry a bare function-local index (LocalInsnId/LocalBlockId/LocalParamId) with no owning FunctionId — SSA is intra-function, so the owning function is the ambient body and does not need re-storing on every operand. The shared/module arms (Literal/Bytes/Varnode/Function) carry the exact same globally-interned or module ids as ValueId (they are already the boundary currency).

The two forms convert through LocalValueId::qualify (stamp the ambient func) and ValueId::localize (drop it, asserting it matched). ValueId stays the qualified boundary currency (module tables, refs, consumer crates); LocalValueId is confined to in-body storage.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Literal(LiteralId)

A compile-time integer constant (module-interned; same id as ValueId).

Bytes(BytesId)

A compile-time opaque byte blob (module-interned; same id as ValueId).

Instruction(LocalInsnId)

An SSA value produced by an Instruction — bare body-local index.

BasicBlock(LocalBlockId)

A control-flow node (BasicBlock) — bare body-local index.

BlockParam(LocalParamId)

A typed block-entry parameter — bare body-local index.

Varnode(VarnodeId)

A named memory location (Varnode) (module id; same as ValueId).

Temp(LocalTempId)

A body-owned temporary value — bare body-local index.

Function(FunctionId)

A lifted or external FunctionBody (module id; same as ValueId).

Poison(PoisonId)

A typed poison value (module-interned; same id as ValueId).

Implementations

impl LocalValueId

pub fn qualify(self, func: FunctionId) -> ValueId

Qualify a body-local id back into the boundary ValueId by stamping the owning function func onto the arena arms. Shared/module arms pass through unchanged.

Trait Implementations

impl Clone for LocalValueId

fn clone(&self) -> LocalValueId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LocalValueId

impl Debug for LocalValueId

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LocalValueId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LocalValueId

impl Hash for LocalValueId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LocalValueId

fn eq(&self, other: &LocalValueId) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for LocalValueId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LocalValueId