Struct rustc_middle::mir::LocalDecl

source ·
pub struct LocalDecl<'tcx> {
    pub mutability: Mutability,
    pub local_info: ClearCrossCrate<Box<LocalInfo<'tcx>>>,
    pub internal: bool,
    pub ty: Ty<'tcx>,
    pub user_ty: Option<Box<UserTypeProjections>>,
    pub source_info: SourceInfo,
}
Expand description

A MIR local.

This can be a binding declared by the user, a temporary inserted by the compiler, a function argument, or the return place.

Fields§

§mutability: Mutability

Whether this is a mutable binding (i.e., let x or let mut x).

Temporaries and the return place are always mutable.

§local_info: ClearCrossCrate<Box<LocalInfo<'tcx>>>§internal: bool

true if this is an internal local.

These locals are not based on types in the source code and are only used for a few desugarings at the moment.

The generator transformation will sanity check the locals which are live across a suspension point against the type components of the generator which type checking knows are live across a suspension point. We need to flag drop flags to avoid triggering this check as they are introduced outside of type inference.

This should be sound because the drop flags are fully algebraic, and therefore don’t affect the auto-trait or outlives properties of the generator.

§ty: Ty<'tcx>

The type of this local.

§user_ty: Option<Box<UserTypeProjections>>

If the user manually ascribed a type to this variable, e.g., via let x: T, then we carry that type here. The MIR borrow checker needs this information since it can affect region inference.

§source_info: SourceInfo

The syntactic (i.e., not visibility) source scope the local is defined in. If the local was defined in a let-statement, this is within the let-statement, rather than outside of it.

This is needed because the visibility source scope of locals within a let-statement is weird.

The reason is that we want the local to be within the let-statement for lint purposes, but we want the local to be after the let-statement for names-in-scope purposes.

That’s it, if we have a let-statement like the one in this function:

fn foo(x: &str) {
    #[allow(unused_mut)]
    let mut x: u32 = { // <- one unused mut
        let mut y: u32 = x.parse().unwrap();
        y + 2
    };
    drop(x);
}

Then, from a lint point of view, the declaration of x: u32 (and y: u32) are within the #[allow(unused_mut)] scope - the lint scopes are the same as the AST/HIR nesting.

However, from a name lookup point of view, the scopes look more like as if the let-statements were match expressions:

fn foo(x: &str) {
    match {
        match x.parse::<u32>().unwrap() {
            y => y + 2
        }
    } {
        x => drop(x)
    };
}

We care about the name-lookup scopes for debuginfo - if the debuginfo instruction pointer is at the call to x.parse(), we want x to refer to x: &str, but if it is at the call to drop(x), we want it to refer to x: u32.

To allow both uses to work, we need to have more than a single scope for a local. We have the source_info.scope represent the “syntactic” lint scope (with a variable being under its let block) while the var_debug_info.source_info.scope represents the “local variable” scope (where the “rest” of a block is under all prior let-statements).

The end result looks like this:

ROOT SCOPE
 │{ argument x: &str }
 │
 │ │{ #[allow(unused_mut)] } // This is actually split into 2 scopes
 │ │                         // in practice because I'm lazy.
 │ │
 │ │← x.source_info.scope
 │ │← `x.parse().unwrap()`
 │ │
 │ │ │← y.source_info.scope
 │ │
 │ │ │{ let y: u32 }
 │ │ │
 │ │ │← y.var_debug_info.source_info.scope
 │ │ │← `y + 2`
 │
 │ │{ let x: u32 }
 │ │← x.var_debug_info.source_info.scope
 │ │← `drop(x)` // This accesses `x: u32`.

Implementations§

source§

impl<'tcx> LocalDecl<'tcx>

source

pub fn local_info(&self) -> &LocalInfo<'tcx>

source

pub fn can_be_made_mutable(&self) -> bool

Returns true only if local is a binding that can itself be made mutable via the addition of the mut keyword, namely something like the occurrences of x in:

  • fn foo(x: Type) { ... },
  • let x = ...,
  • or match ... { C(x) => ... }
source

pub fn is_nonref_binding(&self) -> bool

Returns true if local is definitely not a ref ident or ref mut ident binding. (Such bindings cannot be made into mutable bindings, but the inverse does not necessarily hold).

source

pub fn is_user_variable(&self) -> bool

Returns true if this variable is a named variable or function parameter declared by the user.

source

pub fn is_ref_for_guard(&self) -> bool

Returns true if this is a reference to a variable bound in a match expression that is used to access said variable for the guard of the match arm.

source

pub fn is_ref_to_static(&self) -> bool

Returns Some if this is a reference to a static item that is used to access that static.

source

pub fn is_ref_to_thread_local(&self) -> bool

Returns Some if this is a reference to a thread-local static item that is used to access that static.

source

pub fn is_deref_temp(&self) -> bool

Returns true if this is a DerefTemp

source

pub fn from_compiler_desugaring(&self) -> bool

Returns true is the local is from a compiler desugaring, e.g., __next from a for loop.

source

pub fn new(ty: Ty<'tcx>, span: Span) -> Self

Creates a new LocalDecl for a temporary: mutable, non-internal.

source

pub fn with_source_info(ty: Ty<'tcx>, source_info: SourceInfo) -> Self

Like LocalDecl::new, but takes a SourceInfo instead of a Span.

source

pub fn internal(self) -> Self

Converts self into same LocalDecl except tagged as internal.

source

pub fn immutable(self) -> Self

Converts self into same LocalDecl except tagged as immutable.

Trait Implementations§

source§

impl<'tcx> Clone for LocalDecl<'tcx>

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<'tcx> Debug for LocalDecl<'tcx>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for LocalDecl<'tcx>

source§

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

source§

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for LocalDecl<'tcx>

source§

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

source§

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

source§

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

source§

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

source§

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). Read more
source§

fn fold_with<F>(self, folder: &mut F) -> Selfwhere F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.
source§

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

source§

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

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

Auto Trait Implementations§

§

impl<'tcx> !RefUnwindSafe for LocalDecl<'tcx>

§

impl<'tcx> !Send for LocalDecl<'tcx>

§

impl<'tcx> !Sync for LocalDecl<'tcx>

§

impl<'tcx> Unpin for LocalDecl<'tcx>

§

impl<'tcx> !UnwindSafe for LocalDecl<'tcx>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T, R> CollectAndApply<T, R> for T

source§

fn collect_and_apply<I, F>(iter: I, f: F) -> Rwhere I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

§

type Output = R

source§

impl<Tcx, T> DepNodeParams<Tcx> for Twhere Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

source§

default fn fingerprint_style() -> FingerprintStyle

source§

default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

This method turns the parameters of a DepNodeConstructor into an opaque Fingerprint to be used in DepNode. Not all DepNodeParams support being turned into a Fingerprint (they don’t need to if the corresponding DepNode is anonymous).
source§

default fn to_debug_str(&self, _: Tcx) -> String

source§

default fn recover( _: Tcx, _: &DepNode<<Tcx as DepContext>::DepKind> ) -> Option<T>

This method tries to recover the query key from the given DepNode, something which is needed when forcing DepNodes during red-green evaluation. The query system will only call this method if fingerprint_style() is not FingerprintStyle::Opaque. It is always valid to return None here, in which case incremental compilation will treat the query as having changed instead of forcing it.
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> MaybeResult<T> for T

§

type Error = !

source§

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<'tcx, T> ToPredicate<'tcx, T> for T

source§

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<'tcx, T> TypeVisitableExt<'tcx> for Twhere T: TypeVisitable<TyCtxt<'tcx>>,

source§

fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool

Returns true if self has any late-bound regions that are either bound by binder or bound by some binder outside of binder. If binder is ty::INNERMOST, this indicates whether there are any late-bound regions that appear free.
source§

fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool

Returns true if this type has any regions that escape binder (and hence are not bound by it).
source§

fn has_escaping_bound_vars(&self) -> bool

Return true if this type has regions that are not a part of the type. For example, for<'a> fn(&'a i32) return false, while fn(&'a i32) would return true. The latter can occur when traversing through the former. Read more
source§

fn has_type_flags(&self, flags: TypeFlags) -> bool

source§

fn has_projections(&self) -> bool

source§

fn has_opaque_types(&self) -> bool

source§

fn has_generators(&self) -> bool

source§

fn references_error(&self) -> bool

source§

fn error_reported(&self) -> Result<(), ErrorGuaranteed>

source§

fn has_non_region_param(&self) -> bool

source§

fn has_infer_regions(&self) -> bool

source§

fn has_infer_types(&self) -> bool

source§

fn has_non_region_infer(&self) -> bool

source§

fn needs_infer(&self) -> bool

source§

fn has_placeholders(&self) -> bool

source§

fn needs_subst(&self) -> bool

source§

fn has_free_regions(&self) -> bool

“Free” regions in this context means that it has any region that is not (a) erased or (b) late-bound.
source§

fn has_erased_regions(&self) -> bool

source§

fn has_erasable_regions(&self) -> bool

True if there are any un-erased free regions.
source§

fn is_global(&self) -> bool

Indicates whether this value references only ‘global’ generic parameters that are the same regardless of what fn we are in. This is used for caching.
source§

fn has_late_bound_regions(&self) -> bool

True if there are any late-bound regions
source§

fn has_non_region_late_bound(&self) -> bool

True if there are any late-bound non-region variables
source§

fn has_late_bound_vars(&self) -> bool

True if there are any late-bound variables
source§

fn still_further_specializable(&self) -> bool

Indicates whether this value still has parameters/placeholders/inference variables which could be replaced later, in a way that would change the results of impl specialization.
source§

impl<Tcx, T, D> Value<Tcx, D> for Twhere Tcx: DepContext, D: DepKind,

source§

default fn from_cycle_error(tcx: Tcx, _: &[QueryInfo<D>]) -> T

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: 40 bytes