X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flibrustc%2Fty%2Fcontext.rs;h=4e255edfe85637164a1c1d80c56cc60fd6e43999;hb=fff08cb04389497d254fb40948674cbbee402908;hp=2599b8fbf6ff14a51acf6736c2d6e1a7b7de40c5;hpb=d5643be9b400e3a2966429840f5449e53d428ed4;p=rust.git diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 2599b8fbf6f..4e255edfe85 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -1016,13 +1016,13 @@ pub struct FreeRegionInfo { /// /// [rustc guide]: https://rust-lang.github.io/rustc-guide/ty.html #[derive(Copy, Clone)] -pub struct TyCtxt<'a, 'gcx: 'tcx, 'tcx: 'a> { +pub struct TyCtxt<'gcx: 'tcx, 'tcx> { gcx: &'gcx GlobalCtxt<'gcx>, interners: &'gcx CtxtInterners<'gcx>, - dummy: PhantomData<(&'a (), &'tcx ())>, + dummy: PhantomData<&'tcx ()>, } -impl<'gcx> Deref for TyCtxt<'_, 'gcx, '_> { +impl<'gcx> Deref for TyCtxt<'gcx, '_> { type Target = &'gcx GlobalCtxt<'gcx>; #[inline(always)] fn deref(&self) -> &Self::Target { @@ -1119,10 +1119,10 @@ pub struct GlobalCtxt<'tcx> { output_filenames: Arc, } -impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { +impl<'gcx, 'tcx> TyCtxt<'gcx, 'tcx> { /// Gets the global `TyCtxt`. #[inline] - pub fn global_tcx(self) -> TyCtxt<'gcx, 'gcx, 'gcx> { + pub fn global_tcx(self) -> TyCtxt<'gcx, 'gcx> { TyCtxt { gcx: self.gcx, interners: &self.gcx.global_interners, @@ -1131,7 +1131,7 @@ pub fn global_tcx(self) -> TyCtxt<'gcx, 'gcx, 'gcx> { } #[inline(always)] - pub fn hir(self) -> &'a hir_map::Map<'gcx> { + pub fn hir(self) -> &'tcx hir_map::Map<'gcx> { &self.hir_map } @@ -1469,7 +1469,7 @@ pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc { } #[inline(always)] - pub fn create_stable_hashing_context(self) -> StableHashingContext<'a> { + pub fn create_stable_hashing_context(self) -> StableHashingContext<'tcx> { let krate = self.gcx.hir_map.forest.untracked_krate(); StableHashingContext::new(self.sess, @@ -1666,7 +1666,7 @@ pub fn has_strict_asm_symbol_naming(&self) -> bool { } } -impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { +impl<'tcx> TyCtxt<'tcx, 'tcx> { pub fn encode_metadata(self) -> EncodedMetadata { @@ -1678,12 +1678,9 @@ impl<'gcx> GlobalCtxt<'gcx> { /// Call the closure with a local `TyCtxt` using the given arena. /// `interners` is a slot passed so we can create a CtxtInterners /// with the same lifetime as `arena`. - pub fn enter_local<'tcx, F, R>( - &'gcx self, - f: F - ) -> R + pub fn enter_local<'tcx, F, R>(&'gcx self, f: F) -> R where - F: FnOnce(TyCtxt<'tcx, 'gcx, 'tcx>) -> R, + F: FnOnce(TyCtxt<'gcx, 'tcx>) -> R, 'gcx: 'tcx, { let tcx = TyCtxt { @@ -1706,67 +1703,67 @@ pub fn enter_local<'tcx, F, R>( } } -/// A trait implemented for all X<'a> types which can be safely and -/// efficiently converted to X<'tcx> as long as they are part of the -/// provided TyCtxt<'tcx>. -/// This can be done, for example, for Ty<'tcx> or SubstsRef<'tcx> +/// A trait implemented for all `X<'a>` types that can be safely and +/// efficiently converted to `X<'tcx>` as long as they are part of the +/// provided `TyCtxt<'tcx>`. +/// This can be done, for example, for `Ty<'tcx>` or `SubstsRef<'tcx>` /// by looking them up in their respective interners. /// /// However, this is still not the best implementation as it does /// need to compare the components, even for interned values. -/// It would be more efficient if TypedArena provided a way to +/// It would be more efficient if `TypedArena` provided a way to /// determine whether the address is in the allocated range. /// /// None is returned if the value or one of the components is not part /// of the provided context. -/// For Ty, None can be returned if either the type interner doesn't -/// contain the TyKind key or if the address of the interned +/// For `Ty`, `None` can be returned if either the type interner doesn't +/// contain the `TyKind` key or if the address of the interned /// pointer differs. The latter case is possible if a primitive type, /// e.g., `()` or `u8`, was interned in a different context. pub trait Lift<'tcx>: fmt::Debug { type Lifted: fmt::Debug + 'tcx; - fn lift_to_tcx<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option; + fn lift_to_tcx<'gcx>(&self, tcx: TyCtxt<'gcx, 'tcx>) -> Option; } macro_rules! nop_lift { ($ty:ty => $lifted:ty) => { impl<'a, 'tcx> Lift<'tcx> for $ty { - type Lifted = $lifted; - fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { - if tcx.interners.arena.in_arena(*self as *const _) { - return Some(unsafe { mem::transmute(*self) }); - } - // Also try in the global tcx if we're not that. - if !tcx.is_global() { - self.lift_to_tcx(tcx.global_tcx()) - } else { - None + type Lifted = $lifted; + fn lift_to_tcx<'gcx>(&self, tcx: TyCtxt<'gcx, 'tcx>) -> Option { + if tcx.interners.arena.in_arena(*self as *const _) { + return Some(unsafe { mem::transmute(*self) }); + } + // Also try in the global tcx if we're not that. + if !tcx.is_global() { + self.lift_to_tcx(tcx.global_tcx()) + } else { + None + } + } } - } - } }; } macro_rules! nop_list_lift { ($ty:ty => $lifted:ty) => { impl<'a, 'tcx> Lift<'tcx> for &'a List<$ty> { - type Lifted = &'tcx List<$lifted>; - fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { - if self.is_empty() { - return Some(List::empty()); - } - if tcx.interners.arena.in_arena(*self as *const _) { - return Some(unsafe { mem::transmute(*self) }); - } - // Also try in the global tcx if we're not that. - if !tcx.is_global() { - self.lift_to_tcx(tcx.global_tcx()) - } else { - None + type Lifted = &'tcx List<$lifted>; + fn lift_to_tcx<'gcx>(&self, tcx: TyCtxt<'gcx, 'tcx>) -> Option { + if self.is_empty() { + return Some(List::empty()); + } + if tcx.interners.arena.in_arena(*self as *const _) { + return Some(unsafe { mem::transmute(*self) }); + } + // Also try in the global tcx if we're not that. + if !tcx.is_global() { + self.lift_to_tcx(tcx.global_tcx()) + } else { + None + } + } } - } - } }; } @@ -1815,7 +1812,7 @@ pub mod tls { pub struct ImplicitCtxt<'a, 'gcx: 'tcx, 'tcx> { /// The current TyCtxt. Initially created by `enter_global` and updated /// by `enter_local` with a new local interner - pub tcx: TyCtxt<'tcx, 'gcx, 'tcx>, + pub tcx: TyCtxt<'gcx, 'tcx>, /// The current query job, if any. This is updated by JobOwner::start in /// ty::query::plumbing when executing a query @@ -1941,7 +1938,8 @@ pub fn enter_context<'a, 'gcx: 'tcx, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'gcx /// This happens once per rustc session and TyCtxts only exists /// inside the `f` function. pub fn enter_global<'gcx, F, R>(gcx: &'gcx GlobalCtxt<'gcx>, f: F) -> R - where F: FnOnce(TyCtxt<'gcx, 'gcx, 'gcx>) -> R + where + F: FnOnce(TyCtxt<'gcx, 'gcx>) -> R, { // Update GCX_PTR to indicate there's a GlobalCtxt available GCX_PTR.with(|lock| { @@ -1978,7 +1976,8 @@ pub fn enter_global<'gcx, F, R>(gcx: &'gcx GlobalCtxt<'gcx>, f: F) -> R /// Creates a TyCtxt and ImplicitCtxt based on the GCX_PTR thread local. /// This is used in the deadlock handler. pub unsafe fn with_global(f: F) -> R - where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R + where + F: for<'gcx, 'tcx> FnOnce(TyCtxt<'gcx, 'tcx>) -> R, { let gcx = GCX_PTR.with(|lock| *lock.lock()); assert!(gcx != 0); @@ -2030,8 +2029,9 @@ pub fn with_context(f: F) -> R /// This will panic if you pass it a TyCtxt which has a different global interner from /// the current ImplicitCtxt's tcx field. #[inline] - pub fn with_related_context<'a, 'gcx, 'tcx1, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx1>, f: F) -> R - where F: for<'b, 'tcx2> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx2>) -> R + pub fn with_related_context<'gcx, 'tcx1, F, R>(tcx: TyCtxt<'gcx, 'tcx1>, f: F) -> R + where + F: for<'b, 'tcx2> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx2>) -> R, { with_context(|context| { unsafe { @@ -2048,8 +2048,9 @@ pub fn with_related_context<'a, 'gcx, 'tcx1, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx1>, /// This will panic if you pass it a TyCtxt which has a different global interner or /// a different local interner from the current ImplicitCtxt's tcx field. #[inline] - pub fn with_fully_related_context<'a, 'gcx, 'tcx, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx>, f: F) -> R - where F: for<'b> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx>) -> R + pub fn with_fully_related_context<'gcx, 'tcx, F, R>(tcx: TyCtxt<'gcx, 'tcx>, f: F) -> R + where + F: for<'b> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx>) -> R, { with_context(|context| { unsafe { @@ -2065,7 +2066,8 @@ pub fn with_fully_related_context<'a, 'gcx, 'tcx, F, R>(tcx: TyCtxt<'a, 'gcx, 't /// Panics if there is no ImplicitCtxt available #[inline] pub fn with(f: F) -> R - where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R + where + F: for<'gcx, 'tcx> FnOnce(TyCtxt<'gcx, 'tcx>) -> R, { with_context(|context| f(context.tcx)) } @@ -2074,7 +2076,8 @@ pub fn with(f: F) -> R /// The closure is passed None if there is no ImplicitCtxt available #[inline] pub fn with_opt(f: F) -> R - where F: for<'a, 'gcx, 'tcx> FnOnce(Option>) -> R + where + F: for<'gcx, 'tcx> FnOnce(Option>) -> R, { with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx))) } @@ -2098,7 +2101,7 @@ struct DebugStat { all_infer: usize, } - pub fn go(tcx: TyCtxt<'_, '_, '_>) { + pub fn go(tcx: TyCtxt<'_, '_>) { let mut total = DebugStat { total: 0, lt_infer: 0, @@ -2151,7 +2154,7 @@ pub fn go(tcx: TyCtxt<'_, '_, '_>) { }} } -impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { +impl<'tcx> TyCtxt<'tcx, 'tcx> { pub fn print_debug_stats(self) { sty_debug_print!( self, @@ -2290,7 +2293,7 @@ macro_rules! intern_method { $alloc_method:expr, $alloc_to_key:expr, $keep_in_local_tcx:expr) -> $ty:ty) => { - impl<'a, 'gcx, $lt_tcx> TyCtxt<'a, 'gcx, $lt_tcx> { + impl<'gcx, $lt_tcx> TyCtxt<'gcx, $lt_tcx> { pub fn $method(self, v: $alloc) -> &$lt_tcx $ty { let key = ($alloc_to_key)(&v); @@ -2400,7 +2403,7 @@ macro_rules! slice_interners { ) -> List } -impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { +impl<'gcx, 'tcx> TyCtxt<'gcx, 'tcx> { /// Given a `fn` type, returns an equivalent `unsafe fn` type; /// that is, a `fn` type that is equivalent in every way for being /// unsafe.