Struct rustc_middle::ty::region::Region

pub struct Region<'tcx>(pub Interned<'tcx, RegionKind<'tcx>>);

Use this rather than RegionKind, whenever possible.

Tuple Fields

0: Interned<'tcx, RegionKind<'tcx>>

Implementations

impl<'tcx> Region<'tcx>

pub fn new_early_param( tcx: TyCtxt<'tcx>, early_bound_region: EarlyParamRegion ) -> Region<'tcx>

pub fn new_bound( tcx: TyCtxt<'tcx>, debruijn: DebruijnIndex, bound_region: BoundRegion ) -> Region<'tcx>

pub fn new_late_param( tcx: TyCtxt<'tcx>, scope: DefId, bound_region: BoundRegionKind ) -> Region<'tcx>

pub fn new_var(tcx: TyCtxt<'tcx>, v: RegionVid) -> Region<'tcx>

pub fn new_placeholder( tcx: TyCtxt<'tcx>, placeholder: PlaceholderRegion ) -> Region<'tcx>

pub fn new_error(tcx: TyCtxt<'tcx>, guar: ErrorGuaranteed) -> Region<'tcx>

Constructs a RegionKind::ReError region.

pub fn new_error_misc(tcx: TyCtxt<'tcx>) -> Region<'tcx>

Constructs a RegionKind::ReError region and registers a delayed bug to ensure it gets used.

pub fn new_error_with_message<S: Into<MultiSpan>>( tcx: TyCtxt<'tcx>, span: S, msg: &'static str ) -> Region<'tcx>

Constructs a RegionKind::ReError region and registers a delayed bug with the given msg to ensure it gets used.

pub fn new_from_kind(tcx: TyCtxt<'tcx>, kind: RegionKind<'tcx>) -> Region<'tcx>

Avoid this in favour of more specific new_* methods, where possible, to avoid the cost of the match.

impl<'tcx> Region<'tcx>

Region utilities

pub fn kind(self) -> RegionKind<'tcx>

pub fn get_name(self) -> Option<Symbol>

pub fn get_name_or_anon(self) -> Symbol

pub fn has_name(self) -> bool

Is this region named by the user?

pub fn is_error(self) -> bool

pub fn is_static(self) -> bool

pub fn is_erased(self) -> bool

pub fn is_bound(self) -> bool

pub fn is_placeholder(self) -> bool

pub fn bound_at_or_above_binder(self, index: DebruijnIndex) -> bool

pub fn type_flags(self) -> TypeFlags

pub fn free_region_binding_scope(self, tcx: TyCtxt<'_>) -> DefId

Given an early-bound or free region, returns the DefId where it was bound. For example, consider the regions in this snippet of code:

impl<'a> Foo {
//   ^^ -- early bound, declared on an impl

    fn bar<'b, 'c>(x: &self, y: &'b u32, z: &'c u64) where 'static: 'c
//         ^^  ^^     ^ anonymous, late-bound
//         |   early-bound, appears in where-clauses
//         late-bound, appears only in fn args
    {..}
}

Here, free_region_binding_scope('a) would return the DefId of the impl, and for all the other highlighted regions, it would return the DefId of the function. In other cases (not shown), this function might return the DefId of a closure.

pub fn is_param(self) -> bool

True for free regions other than 'static.

pub fn is_free(self) -> bool

True for free region in the current context.

This is the case for 'static and param regions.

pub fn is_var(self) -> bool

pub fn as_var(self) -> RegionVid

Trait Implementations

impl<'tcx> Clone for Region<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for Region<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for Region<'tcx>

fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>( this: WithInfcx<'_, Infcx, &Self>, f: &mut Formatter<'_> ) -> Result

impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for Region<'tcx>

fn decode(decoder: &mut D) -> Self

impl<'tcx> Deref for Region<'tcx>

type Target = RegionKind<TyCtxt<'tcx>>

The resulting type after dereferencing.

fn deref(&self) -> &RegionKind<'tcx>

Dereferences the value.

impl<'tcx> Display for Region<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for Region<'tcx>

fn encode(&self, e: &mut E)

impl<'tcx> Flags for Region<'tcx>

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<'tcx> From<Region<'tcx>> for GenericArg<'tcx>

fn from(r: Region<'tcx>) -> GenericArg<'tcx>

Converts to this type from the input type.

impl<'tcx> Hash for Region<'tcx>

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<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Region<'tcx>

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

impl<'tcx> IntoKind for Region<'tcx>

type Kind = RegionKind<TyCtxt<'tcx>>

fn kind(self) -> RegionKind<'tcx>

impl<'a, 'tcx> Lift<'tcx> for Region<'a>

type Lifted = Region<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx> Ord for Region<'tcx>

fn cmp(&self, other: &Region<'tcx>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<'tcx> PartialEq for Region<'tcx>

fn eq(&self, other: &Region<'tcx>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> PartialOrd for Region<'tcx>

fn partial_cmp(&self, other: &Region<'tcx>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'tcx, P: Printer<'tcx>> Print<'tcx, P> for Region<'tcx>

fn print(&self, cx: &mut P) -> Result<(), PrintError>

impl<'tcx> Region<TyCtxt<'tcx>> for Region<'tcx>

fn new_anon_bound( tcx: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundVar ) -> Self

impl<'tcx> Relate<'tcx> for Region<'tcx>

fn relate<R: TypeRelation<'tcx>>( relation: &mut R, a: Region<'tcx>, b: Region<'tcx> ) -> RelateResult<'tcx, Region<'tcx>>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Region<'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>(self, folder: &mut F) -> Self

where 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.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Region<'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).

impl<'tcx> Copy for Region<'tcx>

impl<'tcx> Eq for Region<'tcx>

impl<'tcx> StructuralPartialEq for Region<'tcx>

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