Enum rustc_middle::thir::ExprKind

source ·

pub enum ExprKind<'tcx> {
Show 46 variants    Scope {
        region_scope: Scope,
        lint_level: LintLevel,
        value: ExprId,
    },
    Box {
        value: ExprId,
    },
    If {
        if_then_scope: Scope,
        cond: ExprId,
        then: ExprId,
        else_opt: Option<ExprId>,
    },
    Call {
        ty: Ty<'tcx>,
        fun: ExprId,
        args: Box<[ExprId]>,
        from_hir_call: bool,
        fn_span: Span,
    },
    Deref {
        arg: ExprId,
    },
    Binary {
        op: BinOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    LogicalOp {
        op: LogicalOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Unary {
        op: UnOp,
        arg: ExprId,
    },
    Cast {
        source: ExprId,
    },
    Use {
        source: ExprId,
    },
    NeverToAny {
        source: ExprId,
    },
    PointerCoercion {
        cast: PointerCoercion,
        source: ExprId,
    },
    Loop {
        body: ExprId,
    },
    Let {
        expr: ExprId,
        pat: Box<Pat<'tcx>>,
    },
    Match {
        scrutinee: ExprId,
        scrutinee_hir_id: HirId,
        arms: Box<[ArmId]>,
    },
    Block {
        block: BlockId,
    },
    Assign {
        lhs: ExprId,
        rhs: ExprId,
    },
    AssignOp {
        op: BinOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Field {
        lhs: ExprId,
        variant_index: VariantIdx,
        name: FieldIdx,
    },
    Index {
        lhs: ExprId,
        index: ExprId,
    },
    VarRef {
        id: LocalVarId,
    },
    UpvarRef {
        closure_def_id: DefId,
        var_hir_id: LocalVarId,
    },
    Borrow {
        borrow_kind: BorrowKind,
        arg: ExprId,
    },
    AddressOf {
        mutability: Mutability,
        arg: ExprId,
    },
    Break {
        label: Scope,
        value: Option<ExprId>,
    },
    Continue {
        label: Scope,
    },
    Return {
        value: Option<ExprId>,
    },
    Become {
        value: ExprId,
    },
    ConstBlock {
        did: DefId,
        args: GenericArgsRef<'tcx>,
    },
    Repeat {
        value: ExprId,
        count: Const<'tcx>,
    },
    Array {
        fields: Box<[ExprId]>,
    },
    Tuple {
        fields: Box<[ExprId]>,
    },
    Adt(Box<AdtExpr<'tcx>>),
    PlaceTypeAscription {
        source: ExprId,
        user_ty: Option<Box<CanonicalUserType<'tcx>>>,
    },
    ValueTypeAscription {
        source: ExprId,
        user_ty: Option<Box<CanonicalUserType<'tcx>>>,
    },
    Closure(Box<ClosureExpr<'tcx>>),
    Literal {
        lit: &'tcx Lit,
        neg: bool,
    },
    NonHirLiteral {
        lit: ScalarInt,
        user_ty: Option<Box<CanonicalUserType<'tcx>>>,
    },
    ZstLiteral {
        user_ty: Option<Box<CanonicalUserType<'tcx>>>,
    },
    NamedConst {
        def_id: DefId,
        args: GenericArgsRef<'tcx>,
        user_ty: Option<Box<CanonicalUserType<'tcx>>>,
    },
    ConstParam {
        param: ParamConst,
        def_id: DefId,
    },
    StaticRef {
        alloc_id: AllocId,
        ty: Ty<'tcx>,
        def_id: DefId,
    },
    InlineAsm(Box<InlineAsmExpr<'tcx>>),
    OffsetOf {
        container: Ty<'tcx>,
        fields: &'tcx List<(VariantIdx, FieldIdx)>,
    },
    ThreadLocalRef(DefId),
    Yield {
        value: ExprId,
    },
}

Variants§

§

Scope

Fields

§region_scope: Scope

§lint_level: LintLevel

§value: ExprId

Scopes are used to explicitly mark destruction scopes, and to track the HirId of the expressions within the scope.

§

Box

Fields

§value: ExprId

A box <value> expression.

§

If

Fields

§if_then_scope: Scope

§cond: ExprId

§then: ExprId

§else_opt: Option<ExprId>

An if expression.

§

Call

Fields

§ty: Ty<'tcx>

The type of the function. This is often a FnDef or a FnPtr.

§fun: ExprId

The function itself.

§args: Box<[ExprId]>

The arguments passed to the function.

Note: in some cases (like calling a closure), the function call f(...args) gets rewritten as a call to a function trait method (e.g. FnOnce::call_once(f, (...args))).

§from_hir_call: bool

Whether this is from an overloaded operator rather than a function call from HIR. true for overloaded function call.

§fn_span: Span

The span of the function, without the dot and receiver (e.g. foo(a, b) in x.foo(a, b)).

A function call. Method calls and overloaded operators are converted to plain function calls.

§

Deref

Fields

§arg: ExprId

A non-overloaded dereference.

§

Binary

Fields

§op: BinOp

§lhs: ExprId

§rhs: ExprId

A non-overloaded binary operation.

§

LogicalOp

Fields

§op: LogicalOp

§lhs: ExprId

§rhs: ExprId

A logical operation. This is distinct from BinaryOp because the operands need to be lazily evaluated.

§

Unary

Fields

§op: UnOp

§arg: ExprId

A non-overloaded unary operation. Note that here the deref (*) operator is represented by ExprKind::Deref.

§

Cast

Fields

§source: ExprId

A cast: <source> as <type>. The type we cast to is the type of the parent expression.

§

Use

Fields

§source: ExprId

Forces its contents to be treated as a value expression, not a place expression. This is inserted in some places where an operation would otherwise be erased completely (e.g. some no-op casts), but we still need to ensure that its operand is treated as a value and not a place.

§

NeverToAny

Fields

§source: ExprId

A coercion from ! to any type.

§

PointerCoercion

Fields

§cast: PointerCoercion

§source: ExprId

A pointer coercion. More information can be found in PointerCoercion. Pointer casts that cannot be done by coercions are represented by ExprKind::Cast.

§

Loop

Fields

§body: ExprId

A loop expression.

§

Let

Fields

§expr: ExprId

§pat: Box<Pat<'tcx>>

Special expression representing the let part of an if let or similar construct (including if let guards in match arms, and let-chains formed by &&).

This isn’t considered a real expression in surface Rust syntax, so it can only appear in specific situations, such as within the condition of an if.

(Not to be confused with StmtKind::Let, which is a normal let statement.)

§