Store only GlobalCtxt reference in ImplicitCtxt

Author: Zoxc

src/librustc/ty/context.rs

@@ -1606,6 +1606,13 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
 }
 
 impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
+    pub fn tcx(&self) -> TyCtxt<'_, 'gcx, 'gcx> {
+        TyCtxt {
+            gcx: self,
+            interners: &self.global_interners,
+        }
+    }
+
     /// Call the closure with a local `TyCtxt` using the given arena.
     pub fn enter_local<F, R>(
         &self,
@@ -1616,21 +1623,9 @@ impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
         F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
     {
         let interners = CtxtInterners::new(arena);
-        let tcx = TyCtxt {
+        f(TyCtxt {
             gcx: self,
             interners: &interners,
-        };
-        ty::tls::with_related_context(tcx.global_tcx(), |icx| {
-            let new_icx = ty::tls::ImplicitCtxt {
-                tcx,
-                query: icx.query,
-                diagnostics: icx.diagnostics,
-                layout_depth: icx.layout_depth,
-                task: icx.task,
-            };
-            ty::tls::enter_context(&new_icx, |new_icx| {
-                f(new_icx.tcx)
-            })
         })
     }
 }
@@ -1888,10 +1883,10 @@ pub mod tls {
     /// you should also have access to an ImplicitCtxt through the functions
     /// in this module.
     #[derive(Clone)]
-    pub struct ImplicitCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
+    pub struct ImplicitCtxt<'a, 'gcx> {
         /// The current TyCtxt. Initially created by `enter_global` and updated
         /// by `enter_local` with a new local interner
-        pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
+        pub gcx: &'a GlobalCtxt<'gcx>,
 
         /// The current query job, if any. This is updated by start_job in
         /// ty::query::plumbing when executing a query
@@ -2010,9 +2005,9 @@ pub mod tls {
 
     /// Sets `context` as the new current ImplicitCtxt for the duration of the function `f`
     #[inline]
-    pub fn enter_context<'a, 'gcx: 'tcx, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'gcx, 'tcx>,
+    pub fn enter_context<'a, 'gcx, F, R>(context: &ImplicitCtxt<'a, 'gcx>,
                                                      f: F) -> R
-        where F: FnOnce(&ImplicitCtxt<'a, 'gcx, 'tcx>) -> R
+        where F: FnOnce(&ImplicitCtxt<'a, 'gcx>) -> R
     {
         set_tlv(context as *const _ as usize, || {
             f(&context)
@@ -2041,7 +2036,7 @@ pub mod tls {
                 interners: &gcx.global_interners,
             };
             let icx = ImplicitCtxt {
-                tcx,
+                gcx,
                 query: None,
                 diagnostics: None,
                 layout_depth: 0,
@@ -2073,7 +2068,7 @@ pub mod tls {
         let icx = ImplicitCtxt {
             query: None,
             diagnostics: None,
-            tcx,
+            gcx,
             layout_depth: 0,
             task: &OpenTask::Ignore,
         };
@@ -2083,25 +2078,25 @@ pub mod tls {
     /// Allows access to the current ImplicitCtxt in a closure if one is available
     #[inline]
     pub fn with_context_opt<F, R>(f: F) -> R
-        where F: for<'a, 'gcx, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'gcx, 'tcx>>) -> R
+        where F: for<'a, 'gcx> FnOnce(Option<&ImplicitCtxt<'a, 'gcx>>) -> R
     {
         let context = get_tlv();
         if context == 0 {
             f(None)
         } else {
             // We could get a ImplicitCtxt pointer from another thread.
             // Ensure that ImplicitCtxt is Sync
-            sync::assert_sync::<ImplicitCtxt<'_, '_, '_>>();
+            sync::assert_sync::<ImplicitCtxt<'_, '_>>();
 
-            unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_, '_>))) }
+            unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
         }
     }
 
     /// Allows access to the current ImplicitCtxt.
     /// Panics if there is no ImplicitCtxt available
     #[inline]
     pub fn with_context<F, R>(f: F) -> R
-        where F: for<'a, 'gcx, 'tcx> FnOnce(&ImplicitCtxt<'a, 'gcx, 'tcx>) -> R
+        where F: for<'a, 'gcx> FnOnce(&ImplicitCtxt<'a, 'gcx>) -> R
     {
         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
     }
@@ -2112,35 +2107,14 @@ pub mod tls {
     /// 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<'a, 'gcx, 'tcx, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx>, f: F) -> R
+        where F: for<'b> FnOnce(&ImplicitCtxt<'b, 'gcx>) -> R
     {
         with_context(|context| {
             unsafe {
                 let gcx = tcx.gcx as *const _ as usize;
-                assert!(context.tcx.gcx as *const _ as usize == gcx);
-                let context: &ImplicitCtxt<'_, '_, '_> = mem::transmute(context);
-                f(context)
-            }
-        })
-    }
-
-    /// Allows access to the current ImplicitCtxt whose tcx field has the same global
-    /// interner and local interner as the tcx argument passed in. This means the closure
-    /// is given an ImplicitCtxt with the same 'tcx and 'gcx lifetimes as the TyCtxt passed in.
-    /// 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
-    {
-        with_context(|context| {
-            unsafe {
-                let gcx = tcx.gcx as *const _ as usize;
-                let interners = tcx.interners as *const _ as usize;
-                assert!(context.tcx.gcx as *const _ as usize == gcx);
-                assert!(context.tcx.interners as *const _ as usize == interners);
-                let context: &ImplicitCtxt<'_, '_, '_> = mem::transmute(context);
+                assert!(context.gcx as *const _ as usize == gcx);
+                let context: &ImplicitCtxt<'_, '_> = mem::transmute(context);
                 f(context)
             }
         })
@@ -2150,18 +2124,18 @@ pub mod tls {
     /// Panics if there is no ImplicitCtxt available
     #[inline]
     pub fn with<F, R>(f: F) -> R
-        where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+        where F: for<'a, 'gcx> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R
     {
-        with_context(|context| f(context.tcx))
+        with_context(|context| f(context.gcx.tcx()))
     }
 
     /// Allows access to the TyCtxt in the current ImplicitCtxt.
     /// The closure is passed None if there is no ImplicitCtxt available
     #[inline]
     pub fn with_opt<F, R>(f: F) -> R
-        where F: for<'a, 'gcx, 'tcx> FnOnce(Option<TyCtxt<'a, 'gcx, 'tcx>>) -> R
+        where F: for<'a, 'gcx> FnOnce(Option<TyCtxt<'a, 'gcx, 'gcx>>) -> R
     {
-        with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
+        with_context_opt(|opt_context| f(opt_context.map(|context| context.gcx.tcx())))
     }
 }
 

src/librustc/ty/query/plumbing.rs

@@ -296,7 +296,7 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
     {
         // Update the ImplicitCtxt to point to our new query job
         let new_icx = tls::ImplicitCtxt {
-            tcx,
+            gcx: &*tcx,
             query: Some(LrcRef::new(&self.job)),
             diagnostics,
             layout_depth: self.layout_depth,
@@ -405,14 +405,14 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
                 let mut i = 0;
 
                 while let Some(query) = current_query {
-                    let mut db = DiagnosticBuilder::new(icx.tcx.sess.diagnostic(),
+                    let mut db = DiagnosticBuilder::new(icx.gcx.sess.diagnostic(),
                         Level::FailureNote,
                         &format!("#{} [{}] {}",
                                  i,
                                  query.info.query.name(),
-                                 query.info.query.describe(icx.tcx)));
-                    db.set_span(icx.tcx.sess.source_map().def_span(query.info.span));
-                    icx.tcx.sess.diagnostic().force_print_db(db);
+                                 query.info.query.describe(icx.gcx.tcx())));
+                    db.set_span(icx.gcx.sess.source_map().def_span(query.info.span));
+                    icx.gcx.sess.diagnostic().force_print_db(db);
 
                     current_query = query.parent.clone();
                     i += 1;