Unify with_task functions.

Remove with_eval_always_task.

compiler/rustc_query_system/src/dep_graph/graph.rs

@@ -215,24 +215,17 @@ impl<K: DepKind> DepGraph<K> {
         cx: Ctxt,
         arg: A,
         task: fn(Ctxt, A) -> R,
-        hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
+        hash_result: fn(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
     ) -> (R, DepNodeIndex) {
-        self.with_task_impl(
+        if self.is_fully_enabled() {
-            key,
+            self.with_task_impl(key, cx, arg, task, hash_result)
-            cx,
+        } else {
-            arg,
+            // Incremental compilation is turned off. We just execute the task
-            task,
+            // without tracking. We still provide a dep-node index that uniquely
-            |_key| {
+            // identifies the task so that we have a cheap way of referring to
-                Some(TaskDeps {
+            // the query for self-profiling.
-                    #[cfg(debug_assertions)]
+            (task(cx, arg), self.next_virtual_depnode_index())
-                    node: Some(_key),
+        }
-                    reads: SmallVec::new(),
-                    read_set: Default::default(),
-                    phantom_data: PhantomData,
-                })
-            },
-            hash_result,
-        )
     }
 
     fn with_task_impl<Ctxt: HasDepContext<DepKind = K>, A: Debug, R>(
@@ -241,10 +234,11 @@ impl<K: DepKind> DepGraph<K> {
         cx: Ctxt,
         arg: A,
         task: fn(Ctxt, A) -> R,
-        create_task: fn(DepNode<K>) -> Option<TaskDeps<K>>,
+        hash_result: fn(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
-        hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
     ) -> (R, DepNodeIndex) {
-        if let Some(ref data) = self.data {
+        // This function is only called when the graph is enabled.
+        let data = self.data.as_ref().unwrap();
+
         // If the following assertion triggers, it can have two reasons:
         // 1. Something is wrong with DepNode creation, either here or
         //    in `DepGraph::try_mark_green()`.
@@ -259,11 +253,21 @@ impl<K: DepKind> DepGraph<K> {
             key
         );
 
-            let dcx = cx.dep_context();
+        let task_deps = if key.kind.is_eval_always() {
-            let task_deps = create_task(key).map(Lock::new);
+            None
+        } else {
+            Some(Lock::new(TaskDeps {
+                #[cfg(debug_assertions)]
+                node: Some(key),
+                reads: SmallVec::new(),
+                read_set: Default::default(),
+                phantom_data: PhantomData,
+            }))
+        };
         let result = K::with_deps(task_deps.as_ref(), || task(cx, arg));
         let edges = task_deps.map_or_else(|| smallvec![], |lock| lock.into_inner().reads);
 
+        let dcx = cx.dep_context();
         let mut hcx = dcx.create_stable_hashing_context();
         let hashing_timer = dcx.profiler().incr_result_hashing();
         let current_fingerprint = hash_result(&mut hcx, &result);
@@ -271,9 +275,8 @@ impl<K: DepKind> DepGraph<K> {
         let print_status = cfg!(debug_assertions) && dcx.sess().opts.debugging_opts.dep_tasks;
 
         // Get timer for profiling `DepNode` interning
-            let node_intern_timer = self
+        let node_intern_timer =
-                .node_intern_event_id
+            self.node_intern_event_id.map(|eid| dcx.profiler().generic_activity_with_event_id(eid));
-                .map(|eid| dcx.profiler().generic_activity_with_event_id(eid));
         // Intern the new `DepNode`.
         let (dep_node_index, prev_and_color) = data.current.intern_node(
             dcx.profiler(),
@@ -299,13 +302,6 @@ impl<K: DepKind> DepGraph<K> {
         }
 
         (result, dep_node_index)
-        } else {
-            // Incremental compilation is turned off. We just execute the task
-            // without tracking. We still provide a dep-node index that uniquely
-            // identifies the task so that we have a cheap way of referring to
-            // the query for self-profiling.
-            (task(cx, arg), self.next_virtual_depnode_index())
-        }
     }
 
     /// Executes something within an "anonymous" task, that is, a task the
@@ -372,19 +368,6 @@ impl<K: DepKind> DepGraph<K> {
         }
     }
 
-    /// Executes something within an "eval-always" task which is a task
-    /// that runs whenever anything changes.
-    pub fn with_eval_always_task<Ctxt: HasDepContext<DepKind = K>, A: Debug, R>(
-        &self,
-        key: DepNode<K>,
-        cx: Ctxt,
-        arg: A,
-        task: fn(Ctxt, A) -> R,
-        hash_result: impl FnOnce(&mut Ctxt::StableHashingContext, &R) -> Option<Fingerprint>,
-    ) -> (R, DepNodeIndex) {
-        self.with_task_impl(key, cx, arg, task, |_| None, hash_result)
-    }
-
     #[inline]
     pub fn read_index(&self, dep_node_index: DepNodeIndex) {
         if let Some(ref data) = self.data {

compiler/rustc_query_system/src/query/plumbing.rs

@@ -491,15 +491,6 @@ where
         // `to_dep_node` is expensive for some `DepKind`s.
         let dep_node = dep_node_opt.unwrap_or_else(|| query.to_dep_node(*tcx.dep_context(), &key));
 
-        if query.eval_always {
-            tcx.dep_context().dep_graph().with_eval_always_task(
-                dep_node,
-                *tcx.dep_context(),
-                key,
-                compute,
-                query.hash_result,
-            )
-        } else {
         tcx.dep_context().dep_graph().with_task(
             dep_node,
             *tcx.dep_context(),
@@ -507,7 +498,6 @@ where
             compute,
             query.hash_result,
         )
-        }
     });
 
     prof_timer.finish_with_query_invocation_id(dep_node_index.into());