Introduce and use LrcRef in ImplicitCtxt

Author: Zoxc

src/librustc/ty/context.rs

@@ -1878,7 +1878,7 @@ pub mod tls {
     use ty::query;
     use errors::{Diagnostic, TRACK_DIAGNOSTICS};
     use rustc_data_structures::OnDrop;
-    use rustc_data_structures::sync::{self, Lrc, Lock};
+    use rustc_data_structures::sync::{self, Lock, LrcRef};
     use dep_graph::OpenTask;
 
     #[cfg(not(parallel_queries))]
@@ -1900,7 +1900,7 @@ pub mod tls {
 
         /// The current query job, if any. This is updated by start_job in
         /// ty::query::plumbing when executing a query
-        pub query: Option<Lrc<query::QueryJob<'gcx>>>,
+        pub query: Option<LrcRef<'a, query::QueryJob<'gcx>>>,
 
         /// Used to prevent layout from recursing too deeply.
         pub layout_depth: usize,

src/librustc/ty/query/job.rs

@@ -12,7 +12,7 @@
 
 use std::mem;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::sync::{Lock, LockGuard, Lrc, Weak};
+use rustc_data_structures::sync::{Lock, LockGuard, Lrc, LrcRef, Weak};
 use rustc_data_structures::OnDrop;
 use syntax_pos::Span;
 use ty::tls;
@@ -118,7 +118,7 @@ impl<'tcx> QueryJob<'tcx> {
     ) -> Result<(), Box<CycleError<'tcx>>> {
         tls::with_related_context(tcx, move |icx| {
             let mut waiter = Lrc::new(QueryWaiter {
-                query: icx.query.clone(),
+                query: icx.query.map(|q| LrcRef::into(q)),
                 span,
                 cycle: Lock::new(None),
                 condvar: Condvar::new(),
@@ -139,7 +139,9 @@ impl<'tcx> QueryJob<'tcx> {
         span: Span,
     ) -> CycleError<'tcx> {
         // Get the current executing query (waiter) and find the waitee amongst its parents
-        let mut current_job = tls::with_related_context(tcx, |icx| icx.query.clone());
+        let mut current_job = tls::with_related_context(tcx, |icx| {
+            icx.query.map(|q| LrcRef::into(q))
+        });
         let mut cycle = Vec::new();
 
         while let Some(job) = current_job {
@@ -160,7 +162,7 @@ impl<'tcx> QueryJob<'tcx> {
                 return CycleError { usage, cycle };
             }
 
-            current_job = job.parent.clone();
+            current_job = job.parent.as_ref().map(|parent| parent.clone());
         }
 
         panic!("did not find a cycle")

src/librustc/ty/query/plumbing.rs

@@ -26,7 +26,7 @@ use ty::item_path;
 use util::common::{profq_msg, ProfileQueriesMsg, QueryMsg};
 
 use rustc_data_structures::fx::{FxHashMap};
-use rustc_data_structures::sync::{Lrc, Lock};
+use rustc_data_structures::sync::{Lrc, LrcRef, Lock};
 use rustc_data_structures::by_move::{Move, MoveSlot};
 use std::hash::{Hash, Hasher, BuildHasher};
 use std::mem;
@@ -224,7 +224,8 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> {
                             span,
                             query: Q::query(key.clone()),
                         };
-                        let job = Lrc::new(QueryJob::new(info, icx.query.clone()));
+                        let parent = icx.query.map(|q| LrcRef::into(q));
+                        let job = Lrc::new(QueryJob::new(info, parent));
                         let owner = job_storage.init(JobOwner {
                             cache,
                             job: job.clone(),
@@ -296,7 +297,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,
-            query: Some(self.job.clone()),
+            query: Some(LrcRef::new(&self.job)),
             layout_depth: self.layout_depth,
             task,
         };
@@ -387,7 +388,7 @@ impl<'a, 'gcx> TyCtxt<'a, 'gcx, 'gcx> {
 
         tls::with_context_opt(|icx| {
             if let Some(icx) = icx {
-                let mut current_query = icx.query.clone();
+                let mut current_query = icx.query.map(|q| LrcRef::into(q));
                 let mut i = 0;
 
                 while let Some(query) = current_query {

src/librustc_data_structures/sync.rs

@@ -31,6 +31,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, BuildHasher};
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
+use std::mem::ManuallyDrop;
 use owning_ref::{Erased, OwningRef};
 
 pub fn serial_join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
@@ -669,3 +670,40 @@ impl<T> DerefMut for OneThread<T> {
         &mut self.inner
     }
 }
+
+pub struct LrcRef<'a, T: ?Sized>(&'a T);
+
+impl<'a, T: 'a + ?Sized> Clone for LrcRef<'a, T> {
+    fn clone(&self) -> Self {
+        LrcRef(self.0)
+    }
+}
+impl<'a, T: 'a + ?Sized> Copy for LrcRef<'a, T> {}
+
+impl<'a, T: 'a + ?Sized> LrcRef<'a, T> {
+    #[inline]
+    pub fn new(lrc: &Lrc<T>) -> LrcRef<'_, T> {
+        LrcRef(&*lrc)
+    }
+
+    #[inline]
+    pub fn into(self) -> Lrc<T> {
+        unsafe {
+            // We know that we have a reference to an Lrc here.
+            // Pretend to take ownership of the Lrc with from_raw
+            // and the clone a new one.
+            // We use ManuallyDrop to ensure the reference count
+            // isn't decreased
+            let lrc = ManuallyDrop::new(Lrc::from_raw(self.0));
+            (*lrc).clone()
+        }
+    }
+}
+
+impl<'a, T: ?Sized> Deref for LrcRef<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.0
+    }
+}