Enum Expr

pub enum Expr {
    Tuple(ExprTuple),
    Snapshot(ExprSnapshot),
    Desnap(ExprDesnap),
    Assignment(ExprAssignment),
    LogicalOperator(ExprLogicalOperator),
    Block(ExprBlock),
    Loop(ExprLoop),
    While(ExprWhile),
    For(ExprFor),
    FunctionCall(ExprFunctionCall),
    Match(ExprMatch),
    If(ExprIf),
    Var(ExprVar),
    Literal(ExprLiteral),
    StringLiteral(ExprStringLiteral),
    MemberAccess(ExprMemberAccess),
    StructCtor(ExprStructCtor),
    EnumVariantCtor(ExprEnumVariantCtor),
    PropagateError(ExprPropagateError),
    Constant(ExprConstant),
    FixedSizeArray(ExprFixedSizeArray),
    ExprClosure(ExprClosure),
    Missing(ExprMissing),
}

Variants

Tuple(ExprTuple)

Snapshot(ExprSnapshot)

Desnap(ExprDesnap)

Assignment(ExprAssignment)

LogicalOperator(ExprLogicalOperator)

Block(ExprBlock)

Loop(ExprLoop)

While(ExprWhile)

For(ExprFor)

FunctionCall(ExprFunctionCall)

Match(ExprMatch)

If(ExprIf)

Var(ExprVar)

Literal(ExprLiteral)

StringLiteral(ExprStringLiteral)

MemberAccess(ExprMemberAccess)

StructCtor(ExprStructCtor)

EnumVariantCtor(ExprEnumVariantCtor)

PropagateError(ExprPropagateError)

Constant(ExprConstant)

FixedSizeArray(ExprFixedSizeArray)

ExprClosure(ExprClosure)

Missing(ExprMissing)

Implementations

impl Expr

pub fn ty(&self) -> TypeId

pub fn stable_ptr(&self) -> ExprPtr

pub fn as_member_path(&self) -> Option<ExprVarMemberPath>

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<'a, T: ?Sized + Upcast<ExprFormatter<'a>>> DebugWithDb<T> for Expr

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

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>

where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>

where Self: Sized + 'me,

impl From<&Expr> for SyntaxStablePtrId

fn from(expr: &Expr) -> Self

Converts to this type from the input type.

impl Hash for Expr

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 Expr

fn eq(&self, other: &Expr) -> 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<T: SemanticRewriter<ExprTuple, Error> + SemanticRewriter<ExprSnapshot, Error> + SemanticRewriter<ExprDesnap, Error> + SemanticRewriter<ExprAssignment, Error> + SemanticRewriter<ExprLogicalOperator, Error> + SemanticRewriter<ExprBlock, Error> + SemanticRewriter<ExprLoop, Error> + SemanticRewriter<ExprWhile, Error> + SemanticRewriter<ExprFor, Error> + SemanticRewriter<ExprFunctionCall, Error> + SemanticRewriter<ExprMatch, Error> + SemanticRewriter<ExprIf, Error> + SemanticRewriter<ExprVar, Error> + SemanticRewriter<ExprLiteral, Error> + SemanticRewriter<ExprStringLiteral, Error> + SemanticRewriter<ExprMemberAccess, Error> + SemanticRewriter<ExprStructCtor, Error> + SemanticRewriter<ExprEnumVariantCtor, Error> + SemanticRewriter<ExprPropagateError, Error> + SemanticRewriter<ExprConstant, Error> + SemanticRewriter<ExprFixedSizeArray, Error> + SemanticRewriter<ExprClosure, Error> + SemanticRewriter<ExprMissing, Error>, Error> SemanticObject<T, Error> for Expr

fn default_rewrite(&mut self, rewriter: &mut T) -> Result<RewriteResult, Error>

impl<'a> SemanticRewriter<Expr, NoError> for Inference<'a>

fn internal_rewrite( &mut self, value: &mut Expr, ) -> Result<RewriteResult, NoError>

fn rewrite(&mut self, value: T) -> Result<T, Error>

impl Eq for Expr

impl StructuralPartialEq for Expr