Enum cranelift_isle::sema::Expr

pub enum Expr {
    Term(TypeId, TermId, Vec<Expr>),
    Var(TypeId, VarId),
    ConstInt(TypeId, i128),
    ConstPrim(TypeId, Sym),
    Let {
        ty: TypeId,
        bindings: Vec<(VarId, TypeId, Box<Expr>)>,
        body: Box<Expr>,
    },
}

A right-hand side expression of some rule.

Variants

Term(TypeId, TermId, Vec<Expr>)

Invoke this term constructor with the given arguments.

Var(TypeId, VarId)

Get the value of a variable that was bound in the left-hand side.

ConstInt(TypeId, i128)

Get a constant integer.

ConstPrim(TypeId, Sym)

Get a constant primitive.

Let

Fields

ty: TypeId

The type of the result of this let expression.

bindings: Vec<(VarId, TypeId, Box<Expr>)>

The expressions that are evaluated and bound to the given variables.

body: Box<Expr>

The body expression that is evaluated after the bindings.

Evaluate the nested expressions and bind their results to the given variables, then evaluate the body expression.

Implementations

impl Expr

pub fn ty(&self) -> TypeId

Get this expression’s type.

pub fn visit<V: ExprVisitor>(
    &self,
    visitor: &mut V,
    termenv: &TermEnv,
    vars: &HashMap<VarId, V::ExprId>
) -> V::ExprId

Recursively visit every subexpression.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq<Expr> for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr