Struct Region 

pub struct Region<I>(pub <I as Interner>::InternedRegionKind)
where
    I: Interner;

Use this rather than RegionKind, whenever possible.

Tuple Fields

0: <I as Interner>::InternedRegionKind

Implementations

impl<I> Region<I>

where I: Interner,

pub fn new_bound( interner: I, debruijn: DebruijnIndex, bound_region: BoundRegion<I>, ) -> Region<I>

pub fn new_anon_bound( interner: I, debruijn: DebruijnIndex, var: BoundVar, ) -> Region<I>

pub fn new_canonical_bound(interner: I, var: BoundVar) -> Region<I>

pub fn new_placeholder( interner: I, placeholder: Placeholder<I, BoundRegion<I>>, ) -> Region<I>

pub fn new_static(interner: I) -> Region<I>

pub fn is_bound(self) -> bool

pub fn type_flags(self) -> TypeFlags

pub fn kind(self) -> RegionKind<I>

Trait Implementations

impl<I> Clone for Region<I>

where I: Interner,

fn clone(&self) -> Region<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I> Copy for Region<I>

where I: Interner,

impl<I> Debug for Region<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I, D> Decodable<D> for Region<I>

where I: Interner, D: InternerDecoder<Interner = I>, RegionKind<I>: Decodable<D>,

fn decode(decoder: &mut D) -> Region<I>

impl<I> Display for Region<I>

where I: Interner + IrPrint<Region<I>>,

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

Formats the value using the given formatter.

impl<I, E> Encodable<E> for Region<I>

where I: Interner, E: Encoder, RegionKind<I>: Encodable<E>,

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

impl<I> Eq for Region<I>

where I: Interner,

impl<I> Flags for Region<I>

where I: Interner,

fn flags(&self) -> TypeFlags

fn outer_exclusive_binder(&self) -> DebruijnIndex

impl<I> Hash for Region<I>

where I: Interner,

fn hash<__H>(&self, __state: &mut __H)

where __H: Hasher,

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<I> IntoDiagArg for Region<I>

where I: Interner + IrPrint<Region<I>>,

fn into_diag_arg(self, path: &mut Option<PathBuf>) -> DiagArgValue

Convert Self into a DiagArgValue suitable for rendering in a diagnostic.

impl<I> IntoKind for Region<I>

where I: Interner,

type Kind = RegionKind<I>

fn kind(self) -> RegionKind<I>

impl<I, J> Lift<J> for Region<I>

where I: Interner + LiftInto<J>, J: Interner,

type Lifted = Region<J>

fn lift_to_interner(self, interner: J) -> Region<J>

impl<I> PartialEq for Region<I>

where I: Interner,

fn eq(&self, __other: &Region<I>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'tcx, P> Print<P> for Region<TyCtxt<'tcx>>

where P: Printer<'tcx>,

fn print(&self, p: &mut P) -> Result<(), Error>

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

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

Constructs a RegionKind::ReError region.

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

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

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

where S: Into<MultiSpan>,

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

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

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

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

fn new_late_param( tcx: TyCtxt<'tcx>, scope: DefId, kind: LateParamRegionKind, ) -> Region<TyCtxt<'tcx>>

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

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

fn is_named(self, tcx: TyCtxt<'tcx>) -> bool

Is this region named by the user?

fn is_param(self) -> bool

True for free regions other than 'static.

fn is_free(self) -> bool

True for free region in the current context.

This is the case for 'static and param regions.

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.

fn get_name(self, tcx: TyCtxt<'tcx>) -> Option<Symbol>

fn get_name_or_anon(self, tcx: TyCtxt<'tcx>) -> Symbol

fn is_error(self) -> bool

fn is_static(self) -> bool

fn is_erased(self) -> bool

fn is_placeholder(self) -> bool

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

fn is_var(self) -> bool

fn as_var(self) -> RegionVid

impl<I> Relate<I> for Region<I>

where I: Interner,

fn relate<R>( relation: &mut R, a: Region<I>, b: Region<I>, ) -> Result<Region<I>, TypeError<I>>

where R: TypeRelation<I>,

impl<I> StableHash for Region<I>

where I: Interner, <I as Interner>::InternedRegionKind: StableHash,

fn stable_hash<__Hcx>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher<SipHasher128>, )

where __Hcx: StableHashCtxt,

impl<I> TypeFoldable<I> for Region<I>

where I: Interner,

fn try_fold_with<F>( self, folder: &mut F, ) -> Result<Region<I>, <F as FallibleTypeFolder<I>>::Error>

where F: FallibleTypeFolder<I>,

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) -> Region<I>

where F: TypeFolder<I>,

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

impl<I> TypeVisitable<I> for Region<I>

where I: Interner,

fn visit_with<V>(&self, visitor: &mut V) -> <V as TypeVisitor<I>>::Result

where V: TypeVisitor<I>,

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

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.