Remove with_related_context.

There is only one GlobalCtxt ever.

Author: cjgillot

compiler/rustc_middle/src/ty/context.rs

@@ -1684,14 +1684,13 @@ nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
 CloneLiftImpls! { for<'tcx> { Constness, traits::WellFormedLoc, } }
 
 pub mod tls {
-    use super::{ptr_eq, GlobalCtxt, TyCtxt};
+    use super::{GlobalCtxt, TyCtxt};
 
     use crate::dep_graph::{DepKind, TaskDeps};
     use crate::ty::query;
     use rustc_data_structures::sync::{self, Lock};
     use rustc_data_structures::thin_vec::ThinVec;
     use rustc_errors::Diagnostic;
-    use std::mem;
 
     #[cfg(not(parallel_compiler))]
     use std::cell::Cell;
@@ -1811,23 +1810,6 @@ pub mod tls {
         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
     }
 
-    /// Allows access to the current `ImplicitCtxt` whose tcx field is the same as the tcx argument
-    /// passed in. This means the closure is given an `ImplicitCtxt` with the same `'tcx` lifetime
-    /// as the `TyCtxt` passed in.
-    /// This will panic if you pass it a `TyCtxt` which is different from the current
-    /// `ImplicitCtxt`'s `tcx` field.
-    #[inline]
-    pub fn with_related_context<'tcx, F, R>(tcx: TyCtxt<'tcx>, f: F) -> R
-    where
-        F: FnOnce(&ImplicitCtxt<'_, 'tcx>) -> R,
-    {
-        with_context(|context| unsafe {
-            assert!(ptr_eq(context.tcx.gcx, tcx.gcx));
-            let context: &ImplicitCtxt<'_, '_> = mem::transmute(context);
-            f(context)
-        })
-    }
-
     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
     /// Panics if there is no `ImplicitCtxt` available.
     #[inline]
@@ -2834,12 +2816,6 @@ impl<T, R, E> InternIteratorElement<T, R> for Result<T, E> {
     }
 }
 
-// We are comparing types with different invariant lifetimes, so `ptr::eq`
-// won't work for us.
-fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
-    t as *const () == u as *const ()
-}
-
 pub fn provide(providers: &mut ty::query::Providers) {
     providers.in_scope_traits_map =
         |tcx, id| tcx.hir_crate(()).owners[id].as_ref().map(|owner_info| &owner_info.trait_map);

compiler/rustc_middle/src/ty/layout.rs

@@ -216,7 +216,7 @@ fn layout_of<'tcx>(
     tcx: TyCtxt<'tcx>,
     query: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
 ) -> Result<TyAndLayout<'tcx>, LayoutError<'tcx>> {
-    ty::tls::with_related_context(tcx, move |icx| {
+    ty::tls::with_context(move |icx| {
         let (param_env, ty) = query.into_parts();
 
         if !tcx.recursion_limit().value_within_limit(icx.layout_depth) {

compiler/rustc_query_impl/src/plumbing.rs

@@ -46,7 +46,7 @@ impl HasDepContext for QueryCtxt<'tcx> {
 
 impl QueryContext for QueryCtxt<'tcx> {
     fn current_query_job(&self) -> Option<QueryJobId<Self::DepKind>> {
-        tls::with_related_context(**self, |icx| icx.query)
+        tls::with_context(|icx| icx.query)
     }
 
     fn try_collect_active_jobs(&self) -> Option<QueryMap<Self::DepKind>> {
@@ -89,9 +89,9 @@ impl QueryContext for QueryCtxt<'tcx> {
         compute: impl FnOnce() -> R,
     ) -> R {
         // The `TyCtxt` stored in TLS has the same global interner lifetime
-        // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
+        // as `self`, so we use `with_context` to relate the 'tcx lifetimes
         // when accessing the `ImplicitCtxt`.
-        tls::with_related_context(**self, move |current_icx| {
+        tls::with_context(move |current_icx| {
             // Update the `ImplicitCtxt` to point to our new query job.
             let new_icx = ImplicitCtxt {
                 tcx: **self,