Enum ExprKind

pub enum ExprKind {
    Box {
        value: Expr,
    },
    If {
        if_then_scope: Scope,
        cond: Expr,
        then: Expr,
        else_opt: Option<Expr>,
    },
    Call {
        ty: Ty,
        fun: Expr,
        args: Vec<Expr>,
        from_hir_call: bool,
        fn_span: Span,
        generic_args: Vec<GenericArg>,
        bounds_impls: Vec<ImplExpr>,
        trait: Option<(ImplExpr, Vec<GenericArg>)>,
    },
    Deref {
        arg: Expr,
    },
    Binary {
        op: BinOp,
        lhs: Expr,
        rhs: Expr,
    },
    LogicalOp {
        op: LogicalOp,
        lhs: Expr,
        rhs: Expr,
    },
    Unary {
        op: UnOp,
        arg: Expr,
    },
    Cast {
        source: Expr,
    },
    Use {
        source: Expr,
    },
    NeverToAny {
        source: Expr,
    },
    PointerCoercion {
        cast: PointerCoercion,
        source: Expr,
    },
    Loop {
        body: Expr,
    },
    Match {
        scrutinee: Expr,
        arms: Vec<Arm>,
    },
    Let {
        expr: Expr,
        pat: Pat,
    },
    Block {
        block: Block,
    },
    Assign {
        lhs: Expr,
        rhs: Expr,
    },
    AssignOp {
        op: BinOp,
        lhs: Expr,
        rhs: Expr,
    },
    Field {
        field: DefId,
        lhs: Expr,
    },
    TupleField {
        field: usize,
        lhs: Expr,
    },
    Index {
        lhs: Expr,
        index: Expr,
    },
    VarRef {
        id: LocalIdent,
    },
    ConstRef {
        id: ParamConst,
    },
    GlobalName {
        id: GlobalIdent,
        constructor: Option<VariantInformations>,
    },
    UpvarRef {
        closure_def_id: DefId,
        var_hir_id: LocalIdent,
    },
    Borrow {
        borrow_kind: BorrowKind,
        arg: Expr,
    },
    RawBorrow {
        mutability: Mutability,
        arg: Expr,
    },
    Break {
        label: Scope,
        value: Option<Expr>,
    },
    Continue {
        label: Scope,
    },
    Return {
        value: Option<Expr>,
    },
    ConstBlock {
        did: DefId,
        args: Vec<GenericArg>,
    },
    Repeat {
        value: Expr,
        count: ConstantExpr,
    },
    Array {
        fields: Vec<Expr>,
    },
    Tuple {
        fields: Vec<Expr>,
    },
    Adt(AdtExpr),
    PlaceTypeAscription {
        source: Expr,
        user_ty: Option<CanonicalUserType>,
    },
    ValueTypeAscription {
        source: Expr,
        user_ty: Option<CanonicalUserType>,
    },
    Closure {
        params: Vec<Param>,
        body: Expr,
        upvars: Vec<Expr>,
        movability: Option<Movability>,
    },
    Literal {
        lit: Spanned<LitKind>,
        neg: bool,
    },
    ZstLiteral {
        user_ty: Option<CanonicalUserType>,
    },
    NamedConst {
        def_id: GlobalIdent,
        args: Vec<GenericArg>,
        user_ty: Option<CanonicalUserType>,
        impl: Option<ImplExpr>,
    },
    ConstParam {
        param: ParamConst,
        def_id: GlobalIdent,
    },
    StaticRef {
        alloc_id: u64,
        ty: Ty,
        def_id: GlobalIdent,
    },
    Yield {
        value: Expr,
    },
    Todo(String),
}

Reflects thir::ExprKind

Variants

Box

Fields

value: Expr

If

Resugared macros calls. This is deprecated: see https://github.com/hacspec/hax/issues/145.

Fields

if_then_scope: Scope

cond: Expr

then: Expr

else_opt: Option<Expr>

Call

A call to a function or a method.

Example: f(0i8), where f has signature fn f<T: Clone>(t: T) -> ().

Fields

ty: Ty

The type of the function, substitution applied.

Example: for the call f(0i8), this is i8 -> ().

fun: Expr

The function itself. This can be something else than a name, e.g. a closure.

Example: for the call f(0i8), this is f.

args: Vec<Expr>

The arguments given to the function.

Example: for the call f(0i8), this is [0i8].

from_hir_call: bool

fn_span: Span

generic_args: Vec<GenericArg>

The generic arguments given to the function.

Example: for the call f(0i8), this is the type i8.

bounds_impls: Vec<ImplExpr>

The implementations for the bounds of the function.

Example: for the call f(0i8), this is two implementation expressions, one for the explicit bound i8: Clone and one for the implicit i8: Sized.

trait: Option<(ImplExpr, Vec<GenericArg>)>

trait is None if this is a function call or a method to an inherent trait. If this is a method call from a trait Trait, then it contains the concrete implementation of Trait it is called on, and the generic arguments that comes from the trait declaration.

Example: f(0i8) is a function call, hence the field impl is None.

Example:

trait MyTrait<TraitType, const TraitConst: usize> {
  fn meth<MethType>(...) {...}
}
fn example_call<TraitType, SelfType: MyTrait<TraitType, 12>>(x: SelfType) {
  x.meth::<String>(...)
}

Here, in the call x.meth::<String>(...), r#trait will be Some((..., [SelfType, TraitType, 12])), and generic_args will be [String].

Deref

Fields

arg: Expr

Binary

Fields

op: BinOp

lhs: Expr

rhs: Expr

LogicalOp

Fields

op: LogicalOp

lhs: Expr

rhs: Expr

Unary

Fields

op: UnOp

arg: Expr

Cast

Fields

source: Expr

Use

Fields

source: Expr

NeverToAny

Fields

source: Expr

PointerCoercion

Fields

cast: PointerCoercion

source: Expr

Loop

Fields

body: Expr

Match

Fields

scrutinee: Expr

arms: Vec<Arm>

Let

Fields

expr: Expr

pat: Pat

Block

Fields

block: Block

Assign

Fields

lhs: Expr

rhs: Expr

AssignOp

Fields

op: BinOp

lhs: Expr

rhs: Expr

Field

Fields

field: DefId

lhs: Expr

TupleField

Fields

field: usize

lhs: Expr

Index

Fields

lhs: Expr

index: Expr

VarRef

Fields

id: LocalIdent

ConstRef

Fields

id: ParamConst

GlobalName

Fields

id: GlobalIdent

constructor: Option<VariantInformations>

UpvarRef

Fields

closure_def_id: DefId

var_hir_id: LocalIdent

Borrow

Fields

borrow_kind: BorrowKind

arg: Expr

RawBorrow

Fields

mutability: Mutability

arg: Expr

Break

Fields

label: Scope

value: Option<Expr>

Continue

Fields

label: Scope

Return

Fields

value: Option<Expr>

ConstBlock

Fields

did: DefId

args: Vec<GenericArg>

Repeat

Fields

value: Expr

count: ConstantExpr

Array

Fields

fields: Vec<Expr>

Tuple

Fields

fields: Vec<Expr>

Adt(AdtExpr)

PlaceTypeAscription

Fields

source: Expr

user_ty: Option<CanonicalUserType>

ValueTypeAscription

Fields

source: Expr

user_ty: Option<CanonicalUserType>

Closure

Fields

params: Vec<Param>

body: Expr

upvars: Vec<Expr>

movability: Option<Movability>

Literal

Fields

lit: Spanned<LitKind>

neg: bool

ZstLiteral

Fields

user_ty: Option<CanonicalUserType>

NamedConst

Fields

def_id: GlobalIdent

args: Vec<GenericArg>

user_ty: Option<CanonicalUserType>

impl: Option<ImplExpr>

ConstParam

Fields

param: ParamConst

def_id: GlobalIdent

StaticRef

Fields

alloc_id: u64

ty: Ty

def_id: GlobalIdent

Yield

Fields

value: Expr

Todo(String)

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ExprKind

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<'tcx, S: ExprState<'tcx>> SInto<S, ExprKind> for ExprKind<'tcx>

fn sinto(&self, gstate: &S) -> ExprKind

impl Serialize for ExprKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.