Struct 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 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

pub fn opt_param_def_id( self, tcx: TyCtxt<'tcx>, binding_item: DefId, ) -> Option<DefId>

Given some item binding_item, check if this region is a generic parameter introduced by it or one of the parent generics. Returns the DefId of the parameter definition if so.

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, 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 IntoDiagArg for Region<'_>

fn into_diag_arg(self) -> DiagArgValue

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

type Kind = RegionKind<TyCtxt<'tcx>>

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

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

type Lifted = Region<'tcx>

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

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

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_bound( interner: TyCtxt<'tcx>, debruijn: DebruijnIndex, var: BoundRegion, ) -> Self

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

fn new_static(tcx: TyCtxt<'tcx>) -> Self

fn is_bound(self) -> bool

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

fn relate<R: TypeRelation<TyCtxt<'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