Reduce $K and $V usage in query macros.

Within `define_callbacks!`:
- Use `Key<'tcx>` where possible instead of `$($K)*`.
- Use `Value<'tcx>` where possible instead of `$V`.

In the other `define_*!` macros:
- Use `$K:ty` where possible instead of `$($K:tt)*`.
- Add comments about unused `$K` and `$V` cases.
- Add `()` key types to the special nodes in the `define_dep_nodes!`
  invocation for consistency with normal queries.

Author: nnethercote

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -324,11 +324,12 @@ impl StableOrd for WorkProductId {
     const THIS_IMPLEMENTATION_HAS_BEEN_TRIPLE_CHECKED: () = ();
 }
 
+// Note: `$K` and `$V` are unused but present so this can be called by `rustc_with_all_queries`.
 macro_rules! define_dep_nodes {
     (
         $(
             $(#[$attr:meta])*
-            [$($modifiers:tt)*] fn $variant:ident($($K:tt)*) -> $V:ty,
+            [$($modifiers:tt)*] fn $variant:ident($K:ty) -> $V:ty,
         )*
     ) => {
 
@@ -382,20 +383,20 @@ macro_rules! define_dep_nodes {
 }
 
 // Create various data structures for each query, and also for a few things
-// that aren't queries.
+// that aren't queries. The key and return types aren't used, hence the use of `()`.
 rustc_with_all_queries!(define_dep_nodes![
     /// We use this for most things when incr. comp. is turned off.
-    [] fn Null() -> (),
+    [] fn Null(()) -> (),
     /// We use this to create a forever-red node.
-    [] fn Red() -> (),
+    [] fn Red(()) -> (),
     /// We use this to create a side effect node.
-    [] fn SideEffect() -> (),
+    [] fn SideEffect(()) -> (),
     /// We use this to create the anon node with zero dependencies.
-    [] fn AnonZeroDeps() -> (),
-    [] fn TraitSelect() -> (),
-    [] fn CompileCodegenUnit() -> (),
-    [] fn CompileMonoItem() -> (),
-    [] fn Metadata() -> (),
+    [] fn AnonZeroDeps(()) -> (),
+    [] fn TraitSelect(()) -> (),
+    [] fn CompileCodegenUnit(()) -> (),
+    [] fn CompileMonoItem(()) -> (),
+    [] fn Metadata(()) -> (),
 ]);
 
 // WARNING: `construct` is generic and does not know that `CompileCodegenUnit` takes `Symbol`s as keys.

compiler/rustc_middle/src/query/plumbing.rs

@@ -297,6 +297,8 @@ macro_rules! if_return_result_from_ensure_ok {
 
 macro_rules! define_callbacks {
     (
+        // You might expect the key to be `$K:ty`, but it needs to be `$($K:tt)*` so that
+        // `query_helper_param_ty!` can match on specific type names.
         $(
             $(#[$attr:meta])*
             [$($modifiers:tt)*]
@@ -314,17 +316,17 @@ macro_rules! define_callbacks {
 
                 pub type LocalKey<'tcx> = if_separate_provide_extern!(
                     [$($modifiers)*]
-                    (<$($K)* as $crate::query::AsLocalKey>::LocalKey)
-                    ($($K)*)
+                    (<Key<'tcx> as $crate::query::AsLocalKey>::LocalKey)
+                    (Key<'tcx>)
                 );
 
                 /// This type alias specifies the type returned from query providers and the type
                 /// used for decoding. For regular queries this is the declared returned type `V`,
                 /// but `arena_cache` will use `<V as ArenaCached>::Provided` instead.
                 pub type ProvidedValue<'tcx> = if_arena_cache!(
                     [$($modifiers)*]
-                    (<$V as $crate::query::arena_cached::ArenaCached<'tcx>>::Provided)
-                    ($V)
+                    (<Value<'tcx> as $crate::query::arena_cached::ArenaCached<'tcx>>::Provided)
+                    (Value<'tcx>)
                 );
 
                 /// This helper function takes a value returned by the query provider
@@ -341,7 +343,9 @@ macro_rules! define_callbacks {
                     let value: Value<'tcx> = if_arena_cache!(
                         [$($modifiers)*]
                         {
-                            <$V as $crate::query::arena_cached::ArenaCached>::alloc_in_arena(
+                            <Value<'tcx> as $crate::query::arena_cached::ArenaCached>::
+                                alloc_in_arena
+                            (
                                 tcx,
                                 &tcx.query_system.arenas.$name,
                                 provided_value,
@@ -356,7 +360,8 @@ macro_rules! define_callbacks {
                     erase::erase_val(value)
                 }
 
-                pub type Storage<'tcx> = <$($K)* as $crate::query::Key>::Cache<Erased<$V>>;
+                pub type Storage<'tcx> =
+                    <Key<'tcx> as $crate::query::Key>::Cache<Erased<Value<'tcx>>>;
 
                 // Ensure that keys grow no larger than 88 bytes by accident.
                 // Increase this limit if necessary, but do try to keep the size low if possible
@@ -496,7 +501,7 @@ macro_rules! define_callbacks {
         #[derive(Default)]
         pub struct QueryStates<'tcx> {
             $(
-                pub $name: $crate::query::QueryState<'tcx, $($K)*>,
+                pub $name: $crate::query::QueryState<'tcx, $name::Key<'tcx>>,
             )*
         }
 
@@ -573,16 +578,17 @@ macro_rules! define_callbacks {
     };
 }
 
+// Note: `$V` is unused but present so this can be called by `rustc_with_all_queries`.
 macro_rules! define_feedable {
     (
         $(
             $(#[$attr:meta])*
             [$($modifiers:tt)*]
-            fn $name:ident($($K:tt)*) -> $V:ty,
+            fn $name:ident($K:ty) -> $V:ty,
         )*
     ) => {
         $(
-            impl<'tcx, K: $crate::query::IntoQueryParam<$($K)*> + Copy> TyCtxtFeed<'tcx, K> {
+            impl<'tcx, K: $crate::query::IntoQueryParam<$K> + Copy> TyCtxtFeed<'tcx, K> {
                 $(#[$attr])*
                 #[inline(always)]
                 pub fn $name(self, value: $name::ProvidedValue<'tcx>) {

compiler/rustc_query_impl/src/plumbing.rs

@@ -471,13 +471,12 @@ pub(crate) fn force_from_dep_node_inner<'tcx, C: QueryCache, const FLAGS: QueryF
     }
 }
 
-// NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros
-// invoked by `rustc_with_all_queries`.
+// Note: `$K` and `$V` are unused but present so this can be called by `rustc_with_all_queries`.
 macro_rules! define_queries {
     (
         $(
             $(#[$attr:meta])*
-            [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,
+            [$($modifiers:tt)*] fn $name:ident($K:ty) -> $V:ty,
         )*
     ) => {