Enum LocalInfo

pub enum LocalInfo<'tcx> {
    User(BindingForm<'tcx>),
    StaticRef {
        def_id: DefId,
        is_thread_local: bool,
    },
    ConstRef {
        def_id: DefId,
    },
    AggregateTemp,
    BlockTailTemp(BlockTailInfo),
    IfThenRescopeTemp {
        if_then: HirId,
    },
    DerefTemp,
    FakeBorrow,
    Boring,
}

Extra information about a some locals that’s used for diagnostics and for classifying variables into local variables, statics, etc, which is needed e.g. for borrow checking.

Not used for non-StaticRef temporaries, the return place, or anonymous function parameters.

Variants

User(BindingForm<'tcx>)

A user-defined local variable or function parameter

The BindingForm is solely used for local diagnostics when generating warnings/errors when compiling the current crate, and therefore it need not be visible across crates.

StaticRef

A temporary created that references the static with the given DefId.

Fields

def_id: DefId

is_thread_local: bool

ConstRef

A temporary created that references the const with the given DefId

Fields

def_id: DefId

AggregateTemp

A temporary created during the creation of an aggregate (e.g. a temporary for foo in MyStruct { my_field: foo })

BlockTailTemp(BlockTailInfo)

A temporary created for evaluation of some subexpression of some block’s tail expression (with no intervening statement context).

IfThenRescopeTemp

A temporary created during evaluating if predicate, possibly for pattern matching for lets, and subject to Edition 2024 temporary lifetime rules

Fields

if_then: HirId

DerefTemp

A temporary created during the pass Derefer to avoid it’s retagging

FakeBorrow

A temporary created for borrow checking.

Boring

A local without anything interesting about it.

Trait Implementations

impl<'tcx> Clone for LocalInfo<'tcx>

fn clone(&self) -> LocalInfo<'tcx>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for LocalInfo<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for LocalInfo<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for LocalInfo<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for LocalInfo<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for LocalInfo<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F: TypeFolder<TyCtxt<'tcx>>>(self, __folder: &mut __F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for LocalInfo<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes

Size for each variant:

• User: 48 bytes
• StaticRef: 12 bytes
• ConstRef: 8 bytes
• AggregateTemp: 0 bytes
• BlockTailTemp: 12 bytes
• IfThenRescopeTemp: 8 bytes
• DerefTemp: 0 bytes
• FakeBorrow: 0 bytes
• Boring: 0 bytes