Merge trait QueryCacheKey into trait QueryKey.

We have two traits governing query keys, for no particular reason.
This commit combines them.

Author: nnethercote

compiler/rustc_middle/src/query/caches.rs

@@ -1,27 +1,21 @@
-use std::fmt::Debug;
-use std::hash::Hash;
 use std::sync::OnceLock;
 
 use rustc_data_structures::sharded::ShardedHashMap;
-use rustc_data_structures::stable_hasher::HashStable;
 pub use rustc_data_structures::vec_cache::VecCache;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_index::Idx;
 use rustc_span::def_id::{DefId, DefIndex};
 
 use crate::dep_graph::DepNodeIndex;
-use crate::ich::StableHashingContext;
-
-/// Traits that all query keys must satisfy.
-pub trait QueryCacheKey = Hash + Eq + Copy + Debug + for<'a> HashStable<StableHashingContext<'a>>;
+use crate::query::keys::QueryKey;
 
 /// Trait for types that serve as an in-memory cache for query results,
 /// for a given key (argument) type and value (return) type.
 ///
 /// Types implementing this trait are associated with actual key/value types
 /// by the `Cache` associated type of the `rustc_middle::query::Key` trait.
 pub trait QueryCache: Sized {
-    type Key: QueryCacheKey;
+    type Key: QueryKey;
     type Value: Copy;
 
     /// Returns the cached value (and other information) associated with the
@@ -53,7 +47,7 @@ impl<K, V> Default for DefaultCache<K, V> {
 
 impl<K, V> QueryCache for DefaultCache<K, V>
 where
-    K: QueryCacheKey,
+    K: QueryKey,
     V: Copy,
 {
     type Key = K;
@@ -180,7 +174,7 @@ where
 
 impl<K, V> QueryCache for VecCache<K, V, DepNodeIndex>
 where
-    K: Idx + QueryCacheKey,
+    K: Idx + QueryKey,
     V: Copy,
 {
     type Key = K;

compiler/rustc_middle/src/query/keys.rs

@@ -1,13 +1,17 @@
 //! Defines the set of legal keys that can be used in queries.
 
 use std::ffi::OsStr;
+use std::fmt::Debug;
+use std::hash::Hash;
 
 use rustc_ast::tokenstream::TokenStream;
+use rustc_data_structures::stable_hasher::HashStable;
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId};
 use rustc_hir::hir_id::OwnerId;
 use rustc_span::{DUMMY_SP, Ident, LocalExpnId, Span, Symbol};
 
 use crate::dep_graph::DepNodeIndex;
+use crate::ich::StableHashingContext;
 use crate::infer::canonical::CanonicalQueryInput;
 use crate::mir::mono::CollectionMode;
 use crate::query::{DefIdCache, DefaultCache, SingleCache, VecCache};
@@ -20,8 +24,10 @@ use crate::{mir, traits};
 #[derive(Copy, Clone, Debug)]
 pub struct LocalCrate;
 
+pub trait QueryKeyBounds = Copy + Debug + Eq + Hash + for<'a> HashStable<StableHashingContext<'a>>;
+
 /// Controls what types can legally be used as the key for a query.
-pub trait QueryKey: Sized {
+pub trait QueryKey: Sized + QueryKeyBounds {
     /// The type of in-memory cache to use for queries with this key type.
     ///
     /// In practice the cache type must implement [`QueryCache`], though that
@@ -311,13 +317,13 @@ impl<'tcx> QueryKey for &'tcx OsStr {
 
 /// Canonical query goals correspond to abstract trait operations that
 /// are not tied to any crate in particular.
-impl<'tcx, T> QueryKey for CanonicalQueryInput<'tcx, T> {
+impl<'tcx, T: QueryKeyBounds> QueryKey for CanonicalQueryInput<'tcx, T> {
     fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
         DUMMY_SP
     }
 }
 
-impl<'tcx, T> QueryKey for (CanonicalQueryInput<'tcx, T>, bool) {
+impl<'tcx, T: QueryKeyBounds> QueryKey for (CanonicalQueryInput<'tcx, T>, bool) {
     fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
         DUMMY_SP
     }

compiler/rustc_middle/src/query/mod.rs

@@ -1,8 +1,6 @@
 use rustc_hir::def_id::LocalDefId;
 
-pub use self::caches::{
-    DefIdCache, DefaultCache, QueryCache, QueryCacheKey, SingleCache, VecCache,
-};
+pub use self::caches::{DefIdCache, DefaultCache, QueryCache, SingleCache, VecCache};
 pub use self::job::{QueryInfo, QueryJob, QueryJobId, QueryLatch, QueryWaiter};
 pub use self::keys::{AsLocalQueryKey, LocalCrate, QueryKey};
 pub use self::plumbing::{