don't monomorphize with_anon_task for each query

Author: jyn514

compiler/rustc_query_impl/src/plumbing.rs

@@ -52,7 +52,31 @@ impl<'tcx> HasDepContext for QueryCtxt<'tcx> {
     }
 }
 
-impl QueryContext for QueryCtxt<'_> {
+impl<'tcx> QueryCtxt<'tcx> {
+    // Define this closure separately from the one passed to `with_related_context` so it only has to be monomorphized once.
+    fn make_icx<'a>(
+        self,
+        token: QueryJobId,
+        depth_limit: bool,
+        diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
+        current_icx: &ImplicitCtxt<'a, 'tcx>,
+    ) -> ImplicitCtxt<'a, 'tcx> {
+        if depth_limit && !self.recursion_limit().value_within_limit(current_icx.query_depth) {
+            self.depth_limit_error(token);
+        }
+
+        // Update the `ImplicitCtxt` to point to our new query job.
+        ImplicitCtxt {
+            tcx: *self,
+            query: Some(token),
+            diagnostics,
+            query_depth: current_icx.query_depth + depth_limit as usize,
+            task_deps: current_icx.task_deps,
+        }
+    }
+}
+
+impl<'tcx> QueryContext for QueryCtxt<'tcx> {
     fn next_job_id(self) -> QueryJobId {
         QueryJobId(
             NonZeroU64::new(
@@ -110,21 +134,11 @@ impl QueryContext for QueryCtxt<'_> {
         // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
         // when accessing the `ImplicitCtxt`.
         tls::with_related_context(*self, move |current_icx| {
-            if depth_limit && !self.recursion_limit().value_within_limit(current_icx.query_depth) {
-                self.depth_limit_error(token);
-            }
-
-            // Update the `ImplicitCtxt` to point to our new query job.
-            let new_icx = ImplicitCtxt {
-                tcx: *self,
-                query: Some(token),
-                diagnostics,
-                query_depth: current_icx.query_depth + depth_limit as usize,
-                task_deps: current_icx.task_deps,
-            };
-
             // Use the `ImplicitCtxt` while we execute the query.
-            tls::enter_context(&new_icx, compute)
+            tls::enter_context(
+                &self.make_icx(token, depth_limit, diagnostics, current_icx),
+                compute,
+            )
         })
     }
 

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -377,14 +377,14 @@ impl<K: DepKind> DepGraph<K> {
 
     /// Executes something within an "anonymous" task, that is, a task the
     /// `DepNode` of which is determined by the list of inputs it read from.
-    pub fn with_anon_task<Tcx: DepContext<DepKind = K>, OP, R>(
+    pub fn with_anon_task<Tcx: DepContext<DepKind = K>, R>(
         &self,
         cx: Tcx,
         dep_kind: K,
-        op: OP,
+        op: &mut dyn FnMut() -> R,
     ) -> (R, DepNodeIndex)
-    where
-        OP: FnOnce() -> R,
+// where
+    //     OP: FnOnce() -> R,
     {
         debug_assert!(!cx.is_eval_always(dep_kind));
 

compiler/rustc_query_system/src/query/plumbing.rs

@@ -458,7 +458,7 @@ where
     let (result, dep_node_index) =
         qcx.start_query(job_id, query.depth_limit(), Some(&diagnostics), || {
             if query.anon() {
-                return dep_graph.with_anon_task(*qcx.dep_context(), query.dep_kind(), || {
+                return dep_graph.with_anon_task(*qcx.dep_context(), query.dep_kind(), &mut || {
                     query.compute(qcx, key)
                 });
             }

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1417,12 +1417,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         self.check_recursion_depth(obligation.recursion_depth, error_obligation)
     }
 
-    fn in_task<OP, R>(&mut self, op: OP) -> (R, DepNodeIndex)
+    fn in_task<OP, R>(&mut self, mut op: OP) -> (R, DepNodeIndex)
     where
-        OP: FnOnce(&mut Self) -> R,
+        OP: FnMut(&mut Self) -> R,
     {
         let (result, dep_node) =
-            self.tcx().dep_graph.with_anon_task(self.tcx(), DepKind::TraitSelect, || op(self));
+            self.tcx().dep_graph.with_anon_task(self.tcx(), DepKind::TraitSelect, &mut || op(self));
         self.tcx().dep_graph.read_index(dep_node);
         (result, dep_node)
     }