Enum ValueDef 

#[non_exhaustive]
pub enum ValueDef {
    Param {
        block: Block,
        index: u32,
    },
    Result {
        inst: Inst,
        index: u32,
    },
    Detached,
}

Where a value comes from.

Examples

use ir_lang::{Linkage, Module, Signature, Type, ValueDef};

let mut m = Module::new("demo");
let f = m.declare_function("f", &Signature::new(&[Type::I32], &[]), Linkage::Export)?;
let b = m.build(f)?;
let x = b.param(0)?;
assert_eq!(b.func().value_def(x), Some(ValueDef::Param { block: b.func().entry(), index: 0 }));

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.

Param

The index-th parameter of block.

Fields

block: Block

The block.

index: u32

The parameter position.

Result

The index-th result of inst.

Fields

inst: Inst

The instruction.

index: u32

The result position.

Detached

No longer defined: its instruction or block was removed, or its block parameter was removed. Using a detached value is a validation error.

Trait Implementations

impl Clone for ValueDef

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ValueDef

impl Debug for ValueDef

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

Formats the value using the given formatter.

impl Eq for ValueDef

impl Hash for ValueDef

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 ValueDef

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ValueDef