Struct rustc_middle::ty::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_bound( tcx: TyCtxt<'tcx>, early_bound_region: EarlyBoundRegion ) -> Region<'tcx>

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

pub fn new_free( 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>, reported: 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 delay_span_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 delay_span_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_late_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_free(self) -> bool

True for free regions other than 'static.

pub fn is_free_or_static(self) -> bool

True if self is a free region or static.

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<InfCtx: InferCtxtLike<TyCtxt<'tcx>>>( this: OptWithInfcx<'_, TyCtxt<'tcx>, InfCtx, &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> 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<'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) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'tcx> PartialEq<Region<'tcx>> 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<Region<'tcx>> 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>

type Output = <P as Printer<'tcx>>::Region

type Error = <P as Printer<'tcx>>::Error

fn print(&self, cx: P) -> Result<Self::Output, Self::Error>

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

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

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

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

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

impl<'tcx> StructuralEq 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