Enum Binding

pub enum Binding {
    ConstBool {
        val: bool,
        ty: TypeId,
    },
    ConstInt {
        val: i128,
        ty: TypeId,
    },
    ConstPrim {
        val: Sym,
    },
    Argument {
        index: TupleIndex,
    },
    Extractor {
        term: TermId,
        parameter: BindingId,
    },
    Constructor {
        term: TermId,
        parameters: Box<[BindingId]>,
        instance: u32,
    },
    Iterator {
        source: BindingId,
    },
    MakeVariant {
        ty: TypeId,
        variant: VariantId,
        fields: Box<[BindingId]>,
    },
    MatchVariant {
        source: BindingId,
        variant: VariantId,
        field: TupleIndex,
    },
    MakeSome {
        inner: BindingId,
    },
    MatchSome {
        source: BindingId,
    },
    MatchTuple {
        source: BindingId,
        field: TupleIndex,
    },
}

Bindings are anything which can be bound to a variable name in Rust. This includes expressions, such as constants or function calls; but it also includes names bound in pattern matches.

Variants

ConstBool

Evaluates to the given boolean literal.

Fields

val: bool

The constant value.

ty: TypeId

The constant’s type.

ConstInt

Evaluates to the given integer literal.

Fields

val: i128

The constant value.

ty: TypeId

The constant’s type. Unsigned types preserve the representation of val, not its value.

ConstPrim

Evaluates to the given primitive Rust value.

Fields

val: Sym

The constant value.

Argument

One of the arguments to the top-level function.

Fields

index: TupleIndex

Which of the function’s arguments is this?

Extractor

The result of calling an external extractor.

Fields

term: TermId

Which extractor should be called?

parameter: BindingId

What expression should be passed to the extractor?

Constructor

The result of calling an external constructor.

Fields

term: TermId

Which constructor should be called?

parameters: Box<[BindingId]>

What expressions should be passed to the constructor?

instance: u32

For impure constructors, a unique number for each use of this term. Always 0 for pure constructors.

Iterator

The result of getting one value from a multi-constructor or multi-extractor.

Fields

source: BindingId

Which expression produced the iterator that this consumes?

MakeVariant

The result of constructing an enum variant.

Fields

ty: TypeId

Which enum type should be constructed?

variant: VariantId

Which variant of that enum should be constructed?

fields: Box<[BindingId]>

What expressions should be provided for this variant’s fields?

MatchVariant

Pattern-match one of the previous bindings against an enum variant and produce a new binding from one of its fields. There must be a corresponding Constraint::Variant for each source/variant pair that appears in some MatchVariant binding.

Fields

source: BindingId

Which binding is being matched?

variant: VariantId

Which enum variant are we pulling binding sites from? This is somewhat redundant with information in a corresponding Constraint. However, it must be here so that different enum variants aren’t hash-consed into the same binding site.

field: TupleIndex

Which field of this enum variant are we projecting out? Although ISLE uses named fields, we track them by index for constant-time comparisons. The sema::TypeEnv can be used to get the field names.

MakeSome

The result of constructing an Option::Some variant.

Fields

inner: BindingId

Contained expression.

MatchSome

Pattern-match one of the previous bindings against Option::Some and produce a new binding from its contents. There must be a corresponding Constraint::Some for each source that appears in a MatchSome binding. (This currently only happens with external extractors.)

Fields

source: BindingId

Which binding is being matched?

MatchTuple

Pattern-match one of the previous bindings against a tuple and produce a new binding from one of its fields. This is an irrefutable pattern match so there is no corresponding Constraint. (This currently only happens with external extractors.)

Fields

source: BindingId

Which binding is being matched?

field: TupleIndex

Which tuple field are we projecting out?

Implementations

impl Binding

pub fn sources(&self) -> &[BindingId]

Returns the binding sites which must be evaluated before this binding.

Trait Implementations

impl Clone for Binding

fn clone(&self) -> Binding

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Binding

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

Formats the value using the given formatter.

impl Hash for Binding

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 Binding

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Binding

impl StructuralPartialEq for Binding