Move Query to rustc_query_system.

Rename it to QueryStackFrame and document a bit.

4 files changed, 124 insertions, 95 deletions

diff --git a/compiler/rustc_query_system/src/query/config.rs b/compiler/rustc_query_system/src/query/config.rs
index 8239f347923..d01b0de3b48 100644
--- a/compiler/rustc_query_system/src/query/config.rs
+++ b/compiler/rustc_query_system/src/query/config.rs
@@ -27,7 +27,7 @@ pub(crate) struct QueryVtable<CTX: QueryContext, K, V> {
     pub compute: fn(CTX, K) -> V,
 
     pub hash_result: fn(&mut CTX::StableHashingContext, &V) -> Option<Fingerprint>,
-    pub handle_cycle_error: fn(CTX, CycleError<CTX::Query>) -> V,
+    pub handle_cycle_error: fn(CTX, CycleError) -> V,
     pub cache_on_disk: fn(CTX, &K, Option<&V>) -> bool,
     pub try_load_from_disk: fn(CTX, SerializedDepNodeIndex) -> Option<V>,
 }
@@ -52,7 +52,7 @@ impl<CTX: QueryContext, K, V> QueryVtable<CTX, K, V> {
         (self.hash_result)(hcx, value)
     }
 
-    pub(crate) fn handle_cycle_error(&self, tcx: CTX, error: CycleError<CTX::Query>) -> V {
+    pub(crate) fn handle_cycle_error(&self, tcx: CTX, error: CycleError) -> V {
         (self.handle_cycle_error)(tcx, error)
     }
 
@@ -73,7 +73,7 @@ pub trait QueryAccessors<CTX: QueryContext>: QueryConfig {
     type Cache: QueryCache<Key = Self::Key, Stored = Self::Stored, Value = Self::Value>;
 
     // Don't use this method to access query results, instead use the methods on TyCtxt
-    fn query_state<'a>(tcx: CTX) -> &'a QueryState<CTX::DepKind, CTX::Query, Self::Key>
+    fn query_state<'a>(tcx: CTX) -> &'a QueryState<CTX::DepKind, Self::Key>
     where
         CTX: 'a;
 
@@ -90,7 +90,7 @@ pub trait QueryAccessors<CTX: QueryContext>: QueryConfig {
         result: &Self::Value,
     ) -> Option<Fingerprint>;
 
-    fn handle_cycle_error(tcx: CTX, error: CycleError<CTX::Query>) -> Self::Value;
+    fn handle_cycle_error(tcx: CTX, error: CycleError) -> Self::Value;
 }
 
 pub trait QueryDescription<CTX: QueryContext>: QueryAccessors<CTX> {
diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs
index 0ecc2694a79..cc3cefe46be 100644
--- a/compiler/rustc_query_system/src/query/job.rs
+++ b/compiler/rustc_query_system/src/query/job.rs
@@ -1,4 +1,5 @@
 use crate::query::plumbing::CycleError;
+use crate::query::QueryStackFrame;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_span::Span;
@@ -26,13 +27,13 @@ use {
 
 /// Represents a span and a query key.
 #[derive(Clone, Debug)]
-pub struct QueryInfo<Q> {
+pub struct QueryInfo {
     /// The span corresponding to the reason for which this query was required.
     pub span: Span,
-    pub query: Q,
+    pub query: QueryStackFrame,
 }
 
-pub(crate) type QueryMap<D, Q> = FxHashMap<QueryJobId<D>, QueryJobInfo<D, Q>>;
+pub type QueryMap<D> = FxHashMap<QueryJobId<D>, QueryJobInfo<D>>;
 
 /// A value uniquely identifying an active query job within a shard in the query cache.
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
@@ -59,34 +60,34 @@ where
         QueryJobId { job, shard: u16::try_from(shard).unwrap(), kind }
     }
 
-    fn query<Q: Clone>(self, map: &QueryMap<D, Q>) -> Q {
+    fn query(self, map: &QueryMap<D>) -> QueryStackFrame {
         map.get(&self).unwrap().info.query.clone()
     }
 
     #[cfg(parallel_compiler)]
-    fn span<Q: Clone>(self, map: &QueryMap<D, Q>) -> Span {
+    fn span(self, map: &QueryMap<D>) -> Span {
         map.get(&self).unwrap().job.span
     }
 
     #[cfg(parallel_compiler)]
-    fn parent<Q: Clone>(self, map: &QueryMap<D, Q>) -> Option<QueryJobId<D>> {
+    fn parent(self, map: &QueryMap<D>) -> Option<QueryJobId<D>> {
         map.get(&self).unwrap().job.parent
     }
 
     #[cfg(parallel_compiler)]
-    fn latch<'a, Q: Clone>(self, map: &'a QueryMap<D, Q>) -> Option<&'a QueryLatch<D, Q>> {
+    fn latch<'a>(self, map: &'a QueryMap<D>) -> Option<&'a QueryLatch<D>> {
         map.get(&self).unwrap().job.latch.as_ref()
     }
 }
 
-pub struct QueryJobInfo<D, Q> {
-    pub info: QueryInfo<Q>,
-    pub job: QueryJob<D, Q>,
+pub struct QueryJobInfo<D> {
+    pub info: QueryInfo,
+    pub job: QueryJob<D>,
 }
 
 /// Represents an active query job.
 #[derive(Clone)]
-pub struct QueryJob<D, Q> {
+pub struct QueryJob<D> {
     pub id: QueryShardJobId,
 
     /// The span corresponding to the reason for which this query was required.
@@ -97,15 +98,14 @@ pub struct QueryJob<D, Q> {
 
     /// The latch that is used to wait on this job.
     #[cfg(parallel_compiler)]
-    latch: Option<QueryLatch<D, Q>>,
+    latch: Option<QueryLatch<D>>,
 
-    dummy: PhantomData<QueryLatch<D, Q>>,
+    dummy: PhantomData<QueryLatch<D>>,
 }
 
-impl<D, Q> QueryJob<D, Q>
+impl<D> QueryJob<D>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
 {
     /// Creates a new query job.
     pub fn new(id: QueryShardJobId, span: Span, parent: Option<QueryJobId<D>>) -> Self {
@@ -120,7 +120,7 @@ where
     }
 
     #[cfg(parallel_compiler)]
-    pub(super) fn latch(&mut self, _id: QueryJobId<D>) -> QueryLatch<D, Q> {
+    pub(super) fn latch(&mut self, _id: QueryJobId<D>) -> QueryLatch<D> {
         if self.latch.is_none() {
             self.latch = Some(QueryLatch::new());
         }
@@ -128,8 +128,8 @@ where
     }
 
     #[cfg(not(parallel_compiler))]
-    pub(super) fn latch(&mut self, id: QueryJobId<D>) -> QueryLatch<D, Q> {
-        QueryLatch { id, dummy: PhantomData }
+    pub(super) fn latch(&mut self, id: QueryJobId<D>) -> QueryLatch<D> {
+        QueryLatch { id }
     }
 
     /// Signals to waiters that the query is complete.
@@ -148,23 +148,21 @@ where
 
 #[cfg(not(parallel_compiler))]
 #[derive(Clone)]
-pub(super) struct QueryLatch<D, Q> {
+pub(super) struct QueryLatch<D> {
     id: QueryJobId<D>,
-    dummy: PhantomData<Q>,
 }
 
 #[cfg(not(parallel_compiler))]
-impl<D, Q> QueryLatch<D, Q>
+impl<D> QueryLatch<D>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
 {
     pub(super) fn find_cycle_in_stack(
         &self,
-        query_map: QueryMap<D, Q>,
+        query_map: QueryMap<D>,
         current_job: &Option<QueryJobId<D>>,
         span: Span,
-    ) -> CycleError<Q> {
+    ) -> CycleError {
         // Find the waitee amongst `current_job` parents
         let mut cycle = Vec::new();
         let mut current_job = Option::clone(current_job);
@@ -198,15 +196,15 @@ where
 }
 
 #[cfg(parallel_compiler)]
-struct QueryWaiter<D, Q> {
+struct QueryWaiter<D> {
     query: Option<QueryJobId<D>>,
     condvar: Condvar,
     span: Span,
-    cycle: Lock<Option<CycleError<Q>>>,
+    cycle: Lock<Option<CycleError>>,
 }
 
 #[cfg(parallel_compiler)]
-impl<D, Q> QueryWaiter<D, Q> {
+impl<D> QueryWaiter<D> {
     fn notify(&self, registry: &rayon_core::Registry) {
         rayon_core::mark_unblocked(registry);
         self.condvar.notify_one();
@@ -214,19 +212,19 @@ impl<D, Q> QueryWaiter<D, Q> {
 }
 
 #[cfg(parallel_compiler)]
-struct QueryLatchInfo<D, Q> {
+struct QueryLatchInfo<D> {
     complete: bool,
-    waiters: Vec<Lrc<QueryWaiter<D, Q>>>,
+    waiters: Vec<Lrc<QueryWaiter<D>>>,
 }
 
 #[cfg(parallel_compiler)]
 #[derive(Clone)]
-pub(super) struct QueryLatch<D, Q> {
-    info: Lrc<Mutex<QueryLatchInfo<D, Q>>>,
+pub(super) struct QueryLatch<D> {
+    info: Lrc<Mutex<QueryLatchInfo<D>>>,
 }
 
 #[cfg(parallel_compiler)]
-impl<D: Eq + Hash, Q: Clone> QueryLatch<D, Q> {
+impl<D: Eq + Hash> QueryLatch<D> {
     fn new() -> Self {
         QueryLatch {
             info: Lrc::new(Mutex::new(QueryLatchInfo { complete: false, waiters: Vec::new() })),
@@ -235,13 +233,13 @@ impl<D: Eq + Hash, Q: Clone> QueryLatch<D, Q> {
 }
 
 #[cfg(parallel_compiler)]
-impl<D, Q> QueryLatch<D, Q> {
+impl<D> QueryLatch<D> {
     /// Awaits for the query job to complete.
     pub(super) fn wait_on(
         &self,
         query: Option<QueryJobId<D>>,
         span: Span,
-    ) -> Result<(), CycleError<Q>> {
+    ) -> Result<(), CycleError> {
         let waiter =
             Lrc::new(QueryWaiter { query, span, cycle: Lock::new(None), condvar: Condvar::new() });
         self.wait_on_inner(&waiter);
@@ -256,7 +254,7 @@ impl<D, Q> QueryLatch<D, Q> {
     }
 
     /// Awaits the caller on this latch by blocking the current thread.
-    fn wait_on_inner(&self, waiter: &Lrc<QueryWaiter<D, Q>>) {
+    fn wait_on_inner(&self, waiter: &Lrc<QueryWaiter<D>>) {
         let mut info = self.info.lock();
         if !info.complete {
             // We push the waiter on to the `waiters` list. It can be accessed inside
@@ -290,7 +288,7 @@ impl<D, Q> QueryLatch<D, Q> {
 
     /// Removes a single waiter from the list of waiters.
     /// This is used to break query cycles.
-    fn extract_waiter(&self, waiter: usize) -> Lrc<QueryWaiter<D, Q>> {
+    fn extract_waiter(&self, waiter: usize) -> Lrc<QueryWaiter<D>> {
         let mut info = self.info.lock();
         debug_assert!(!info.complete);
         // Remove the waiter from the list of waiters
@@ -312,14 +310,13 @@ type Waiter<D> = (QueryJobId<D>, usize);
 /// required information to resume the waiter.
 /// If all `visit` calls returns None, this function also returns None.
 #[cfg(parallel_compiler)]
-fn visit_waiters<D, Q, F>(
-    query_map: &QueryMap<D, Q>,
+fn visit_waiters<D, F>(
+    query_map: &QueryMap<D>,
     query: QueryJobId<D>,
     mut visit: F,
 ) -> Option<Option<Waiter<D>>>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     F: FnMut(Span, QueryJobId<D>) -> Option<Option<Waiter<D>>>,
 {
     // Visit the parent query which is a non-resumable waiter since it's on the same stack
@@ -349,8 +346,8 @@ where
 /// If a cycle is detected, this initial value is replaced with the span causing
 /// the cycle.
 #[cfg(parallel_compiler)]
-fn cycle_check<D, Q>(
-    query_map: &QueryMap<D, Q>,
+fn cycle_check<D>(
+    query_map: &QueryMap<D>,
     query: QueryJobId<D>,
     span: Span,
     stack: &mut Vec<(Span, QueryJobId<D>)>,
@@ -358,7 +355,6 @@ fn cycle_check<D, Q>(
 ) -> Option<Option<Waiter<D>>>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
 {
     if !visited.insert(query) {
         return if let Some(p) = stack.iter().position(|q| q.1 == query) {
@@ -394,14 +390,13 @@ where
 /// from `query` without going through any of the queries in `visited`.
 /// This is achieved with a depth first search.
 #[cfg(parallel_compiler)]
-fn connected_to_root<D, Q>(
-    query_map: &QueryMap<D, Q>,
+fn connected_to_root<D>(
+    query_map: &QueryMap<D>,
     query: QueryJobId<D>,
     visited: &mut FxHashSet<QueryJobId<D>>,
 ) -> bool
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
 {
     // We already visited this or we're deliberately ignoring it
     if !visited.insert(query) {
@@ -422,7 +417,7 @@ where
 // Deterministically pick an query from a list
 #[cfg(parallel_compiler)]
 fn pick_query<'a, CTX, T, F>(
-    query_map: &QueryMap<CTX::DepKind, CTX::Query>,
+    query_map: &QueryMap<CTX::DepKind>,
     tcx: CTX,
     queries: &'a [T],
     f: F,
@@ -456,9 +451,9 @@ where
 /// the function returns false.
 #[cfg(parallel_compiler)]
 fn remove_cycle<CTX: QueryContext>(
-    query_map: &QueryMap<CTX::DepKind, CTX::Query>,
+    query_map: &QueryMap<CTX::DepKind>,
     jobs: &mut Vec<QueryJobId<CTX::DepKind>>,
-    wakelist: &mut Vec<Lrc<QueryWaiter<CTX::DepKind, CTX::Query>>>,
+    wakelist: &mut Vec<Lrc<QueryWaiter<CTX::DepKind>>>,
     tcx: CTX,
 ) -> bool {
     let mut visited = FxHashSet::default();
diff --git a/compiler/rustc_query_system/src/query/mod.rs b/compiler/rustc_query_system/src/query/mod.rs
index bc5ad2cc385..7b46674c743 100644
--- a/compiler/rustc_query_system/src/query/mod.rs
+++ b/compiler/rustc_query_system/src/query/mod.rs
@@ -4,7 +4,7 @@ pub use self::plumbing::*;
 mod job;
 #[cfg(parallel_compiler)]
 pub use self::job::deadlock;
-pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryJobInfo};
+pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryJobInfo, QueryMap};
 
 mod caches;
 pub use self::caches::{
@@ -15,24 +15,63 @@ mod config;
 pub use self::config::{QueryAccessors, QueryConfig, QueryDescription};
 
 use crate::dep_graph::{DepNode, DepNodeIndex, HasDepContext, SerializedDepNodeIndex};
-use crate::query::job::QueryMap;
 
-use rustc_data_structures::stable_hasher::HashStable;
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::Lock;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::Diagnostic;
 use rustc_span::def_id::DefId;
+use rustc_span::Span;
 
-pub trait QueryContext: HasDepContext {
-    type Query: Clone + HashStable<Self::StableHashingContext>;
+/// Description of a frame in the query stack.
+///
+/// This is mostly used in case of cycles for error reporting.
+#[derive(Clone, Debug)]
+pub struct QueryStackFrame {
+    pub name: &'static str,
+    pub description: String,
+    span: Option<Span>,
+    /// This hash is used to deterministically pick
+    /// a query to remove cycles in the parallel compiler.
+    hash: Fingerprint,
+}
+
+impl QueryStackFrame {
+    #[inline]
+    pub fn new(
+        name: &'static str,
+        description: String,
+        span: Option<Span>,
+        hash: Fingerprint,
+    ) -> Self {
+        Self { name, hash, description, span }
+    }
+
+    // FIXME(eddyb) Get more valid `Span`s on queries.
+    #[inline]
+    pub fn default_span(&self, span: Span) -> Span {
+        if !span.is_dummy() {
+            return span;
+        }
+        self.span.unwrap_or(span)
+    }
+}
+
+impl<CTX> HashStable<CTX> for QueryStackFrame {
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        self.hash.hash_stable(hcx, hasher)
+    }
+}
 
+pub trait QueryContext: HasDepContext {
     /// Get string representation from DefPath.
     fn def_path_str(&self, def_id: DefId) -> String;
 
     /// Get the query information from the TLS context.
     fn current_query_job(&self) -> Option<QueryJobId<Self::DepKind>>;
 
-    fn try_collect_active_jobs(&self) -> Option<QueryMap<Self::DepKind, Self::Query>>;
+    fn try_collect_active_jobs(&self) -> Option<QueryMap<Self::DepKind>>;
 
     /// Load data from the on-disk cache.
     fn try_load_from_on_disk_cache(&self, dep_node: &DepNode<Self::DepKind>);
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
index dbe7c4c2320..28ee1a17994 100644
--- a/compiler/rustc_query_system/src/query/plumbing.rs
+++ b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -7,7 +7,7 @@ use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 use crate::query::caches::QueryCache;
 use crate::query::config::{QueryDescription, QueryVtable, QueryVtableExt};
 use crate::query::job::{QueryInfo, QueryJob, QueryJobId, QueryJobInfo, QueryShardJobId};
-use crate::query::{QueryContext, QueryMap};
+use crate::query::{QueryContext, QueryMap, QueryStackFrame};
 
 #[cfg(not(parallel_compiler))]
 use rustc_data_structures::cold_path;
@@ -81,37 +81,36 @@ impl<C: QueryCache> QueryCacheStore<C> {
     }
 }
 
-struct QueryStateShard<D, Q, K> {
-    active: FxHashMap<K, QueryResult<D, Q>>,
+struct QueryStateShard<D, K> {
+    active: FxHashMap<K, QueryResult<D>>,
 
     /// Used to generate unique ids for active jobs.
     jobs: u32,
 }
 
-impl<D, Q, K> Default for QueryStateShard<D, Q, K> {
-    fn default() -> QueryStateShard<D, Q, K> {
+impl<D, K> Default for QueryStateShard<D, K> {
+    fn default() -> QueryStateShard<D, K> {
         QueryStateShard { active: Default::default(), jobs: 0 }
     }
 }
 
-pub struct QueryState<D, Q, K> {
-    shards: Sharded<QueryStateShard<D, Q, K>>,
+pub struct QueryState<D, K> {
+    shards: Sharded<QueryStateShard<D, K>>,
 }
 
 /// Indicates the state of a query for a given key in a query map.
-enum QueryResult<D, Q> {
+enum QueryResult<D> {
     /// An already executing query. The query job can be used to await for its completion.
-    Started(QueryJob<D, Q>),
+    Started(QueryJob<D>),
 
     /// The query panicked. Queries trying to wait on this will raise a fatal error which will
     /// silently panic.
     Poisoned,
 }
 
-impl<D, Q, K> QueryState<D, Q, K>
+impl<D, K> QueryState<D, K>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     K: Eq + Hash + Clone + Debug,
 {
     pub fn all_inactive(&self) -> bool {
@@ -123,8 +122,8 @@ where
         &self,
         tcx: CTX,
         kind: D,
-        make_query: fn(CTX, K) -> Q,
-        jobs: &mut QueryMap<D, Q>,
+        make_query: fn(CTX, K) -> QueryStackFrame,
+        jobs: &mut QueryMap<D>,
     ) -> Option<()> {
         // We use try_lock_shards here since we are called from the
         // deadlock handler, and this shouldn't be locked.
@@ -146,30 +145,28 @@ where
     }
 }
 
-impl<D, Q, K> Default for QueryState<D, Q, K> {
-    fn default() -> QueryState<D, Q, K> {
+impl<D, K> Default for QueryState<D, K> {
+    fn default() -> QueryState<D, K> {
         QueryState { shards: Default::default() }
     }
 }
 
 /// A type representing the responsibility to execute the job in the `job` field.
 /// This will poison the relevant query if dropped.
-struct JobOwner<'tcx, D, Q, C>
+struct JobOwner<'tcx, D, C>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     C: QueryCache,
 {
-    state: &'tcx QueryState<D, Q, C::Key>,
+    state: &'tcx QueryState<D, C::Key>,
     cache: &'tcx QueryCacheStore<C>,
     key: C::Key,
     id: QueryJobId<D>,
 }
 
-impl<'tcx, D, Q, C> JobOwner<'tcx, D, Q, C>
+impl<'tcx, D, C> JobOwner<'tcx, D, C>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     C: QueryCache,
 {
     /// Either gets a `JobOwner` corresponding the query, allowing us to
@@ -183,13 +180,13 @@ where
     #[inline(always)]
     fn try_start<'b, CTX>(
         tcx: CTX,
-        state: &'b QueryState<CTX::DepKind, CTX::Query, C::Key>,
+        state: &'b QueryState<CTX::DepKind, C::Key>,
         cache: &'b QueryCacheStore<C>,
         span: Span,
         key: &C::Key,
         lookup: QueryLookup,
         query: &QueryVtable<CTX, C::Key, C::Value>,
-    ) -> TryGetJob<'b, CTX::DepKind, CTX::Query, C>
+    ) -> TryGetJob<'b, CTX::DepKind, C>
     where
         CTX: QueryContext,
     {
@@ -243,7 +240,7 @@ where
         // so we just return the error.
         #[cfg(not(parallel_compiler))]
         return TryGetJob::Cycle(cold_path(|| {
-            let error: CycleError<CTX::Query> = latch.find_cycle_in_stack(
+            let error: CycleError = latch.find_cycle_in_stack(
                 tcx.try_collect_active_jobs().unwrap(),
                 &tcx.current_query_job(),
                 span,
@@ -328,10 +325,9 @@ where
     (result, diagnostics.into_inner())
 }
 
-impl<'tcx, D, Q, C> Drop for JobOwner<'tcx, D, Q, C>
+impl<'tcx, D, C> Drop for JobOwner<'tcx, D, C>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     C: QueryCache,
 {
     #[inline(never)]
@@ -356,21 +352,20 @@ where
 }
 
 #[derive(Clone)]
-pub struct CycleError<Q> {
+pub struct CycleError {
     /// The query and related span that uses the cycle.
-    pub usage: Option<(Span, Q)>,
-    pub cycle: Vec<QueryInfo<Q>>,
+    pub usage: Option<(Span, QueryStackFrame)>,
+    pub cycle: Vec<QueryInfo>,
 }
 
 /// The result of `try_start`.
-enum TryGetJob<'tcx, D, Q, C>
+enum TryGetJob<'tcx, D, C>
 where
     D: Copy + Clone + Eq + Hash,
-    Q: Clone,
     C: QueryCache,
 {
     /// The query is not yet started. Contains a guard to the cache eventually used to start it.
-    NotYetStarted(JobOwner<'tcx, D, Q, C>),
+    NotYetStarted(JobOwner<'tcx, D, C>),
 
     /// The query was already completed.
     /// Returns the result of the query and its dep-node index
@@ -414,7 +409,7 @@ where
 
 fn try_execute_query<CTX, C>(
     tcx: CTX,
-    state: &QueryState<CTX::DepKind, CTX::Query, C::Key>,
+    state: &QueryState<CTX::DepKind, C::Key>,
     cache: &QueryCacheStore<C>,
     span: Span,
     key: C::Key,
@@ -426,7 +421,7 @@ where
     C::Key: crate::dep_graph::DepNodeParams<CTX::DepContext>,
     CTX: QueryContext,
 {
-    let job = match JobOwner::<'_, CTX::DepKind, CTX::Query, C>::try_start(
+    let job = match JobOwner::<'_, CTX::DepKind, C>::try_start(
         tcx, state, cache, span, &key, lookup, query,
     ) {
         TryGetJob::NotYetStarted(job) => job,
@@ -590,7 +585,7 @@ fn incremental_verify_ich<CTX, K, V: Debug>(
 fn force_query_with_job<C, CTX>(
     tcx: CTX,
     key: C::Key,
-    job: JobOwner<'_, CTX::DepKind, CTX::Query, C>,
+    job: JobOwner<'_, CTX::DepKind, C>,
     dep_node: DepNode<CTX::DepKind>,
     query: &QueryVtable<CTX, C::Key, C::Value>,
 ) -> (C::Stored, DepNodeIndex)
@@ -650,7 +645,7 @@ where
 #[inline(never)]
 fn get_query_impl<CTX, C>(
     tcx: CTX,
-    state: &QueryState<CTX::DepKind, CTX::Query, C::Key>,
+    state: &QueryState<CTX::DepKind, C::Key>,
     cache: &QueryCacheStore<C>,
     span: Span,
     key: C::Key,
@@ -708,7 +703,7 @@ where
 #[inline(never)]
 fn force_query_impl<CTX, C>(
     tcx: CTX,
-    state: &QueryState<CTX::DepKind, CTX::Query, C::Key>,
+    state: &QueryState<CTX::DepKind, C::Key>,
     cache: &QueryCacheStore<C>,
     key: C::Key,
     span: Span,
@@ -736,7 +731,7 @@ fn force_query_impl<CTX, C>(
         Err(lookup) => lookup,
     };
 
-    let job = match JobOwner::<'_, CTX::DepKind, CTX::Query, C>::try_start(
+    let job = match JobOwner::<'_, CTX::DepKind, C>::try_start(
         tcx, state, cache, span, &key, lookup, query,
     ) {
         TryGetJob::NotYetStarted(job) => job,