fix for QueryKey

Author: Jamesbarford

compiler/rustc_middle/src/ty/layout.rs

@@ -722,13 +722,10 @@ impl<'tcx> LayoutOfHelpers<'tcx> for LayoutCx<'tcx> {
     }
 }
 
-impl<'tcx, C> TyAbiInterface<'tcx, C> for Ty<'tcx>
-where
-    C: HasTyCtxt<'tcx> + HasTypingEnv<'tcx>,
-{
+impl<'tcx> TyAbiInterface<'tcx, LayoutCx<'tcx>> for Ty<'tcx> {
     fn ty_and_layout_for_variant(
         this: TyAndLayout<'tcx>,
-        cx: &C,
+        cx: &LayoutCx<'tcx>,
         variant_index: VariantIdx,
     ) -> TyAndLayout<'tcx> {
         let layout = match this.variants {
@@ -770,7 +767,11 @@ where
         TyAndLayout { ty: this.ty, layout }
     }
 
-    fn ty_and_layout_field(this: TyAndLayout<'tcx>, cx: &C, i: usize) -> TyAndLayout<'tcx> {
+    fn ty_and_layout_field(
+        this: TyAndLayout<'tcx>,
+        cx: &LayoutCx<'tcx>,
+        i: usize,
+    ) -> TyAndLayout<'tcx> {
         enum TyMaybeWithLayout<'tcx> {
             Ty(Ty<'tcx>),
             TyAndLayout(TyAndLayout<'tcx>),
@@ -968,7 +969,7 @@ where
     /// This will recurse into fields of ADTs to find the inner pointer.
     fn ty_and_layout_pointee_info_at(
         this: TyAndLayout<'tcx>,
-        cx: &C,
+        cx: &LayoutCx<'tcx>,
         offset: Size,
     ) -> Option<PointeeInfo> {
         let tcx = cx.tcx();

compiler/rustc_type_ir/src/binder.rs

@@ -5,6 +5,8 @@ use std::ops::{ControlFlow, Deref};
 
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+#[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
 use rustc_type_ir_macros::{
     GenericTypeVisitable, Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic,
@@ -1010,10 +1012,7 @@ where
 
 #[derive_where(Clone, Copy, PartialEq, Eq, Hash; I: Interner)]
 #[derive(Lift_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
-)]
+#[cfg_attr(feature = "nightly", derive(Encodable_NoContext, Decodable_NoContext))]
 pub enum BoundRegionKind<I: Interner> {
     /// An anonymous region parameter for a given fn (&T)
     Anon,
@@ -1072,21 +1071,15 @@ impl<I: Interner> BoundRegionKind<I> {
 
 #[derive_where(Clone, Copy, PartialEq, Eq, Debug, Hash; I: Interner)]
 #[derive(Lift_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
-)]
+#[cfg_attr(feature = "nightly", derive(Encodable_NoContext, Decodable_NoContext))]
 pub enum BoundTyKind<I: Interner> {
     Anon,
     Param(I::DefId),
 }
 
 #[derive_where(Clone, Copy, PartialEq, Eq, Debug, Hash; I: Interner)]
 #[derive(Lift_Generic)]
-#[cfg_attr(
-    feature = "nightly",
-    derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
-)]
+#[cfg_attr(feature = "nightly", derive(Encodable_NoContext, Decodable_NoContext))]
 pub enum BoundVariableKind<I: Interner> {
     Ty(BoundTyKind<I>),
     Region(BoundRegionKind<I>),
@@ -1116,6 +1109,58 @@ impl<I: Interner> BoundVariableKind<I> {
     }
 }
 
+#[cfg(feature = "nightly")]
+// This is not a derived impl because a derive would require `I: HashStable`.
+impl<CTX, I: Interner> HashStable<CTX> for BoundRegionKind<I>
+where
+    I::DefId: HashStable<CTX>,
+    I::Symbol: HashStable<CTX>,
+{
+    #[inline]
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        std::mem::discriminant(self).hash_stable(hcx, hasher);
+        match self {
+            BoundRegionKind::Anon | BoundRegionKind::ClosureEnv => {}
+            BoundRegionKind::NamedForPrinting(sym) => sym.hash_stable(hcx, hasher),
+            BoundRegionKind::Named(def_id) => def_id.hash_stable(hcx, hasher),
+        }
+    }
+}
+
+#[cfg(feature = "nightly")]
+// This is not a derived impl because a derive would require `I: HashStable`.
+impl<CTX, I: Interner> HashStable<CTX> for BoundTyKind<I>
+where
+    I::DefId: HashStable<CTX>,
+{
+    #[inline]
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        std::mem::discriminant(self).hash_stable(hcx, hasher);
+        match self {
+            BoundTyKind::Anon => {}
+            BoundTyKind::Param(def_id) => def_id.hash_stable(hcx, hasher),
+        }
+    }
+}
+
+#[cfg(feature = "nightly")]
+// This is not a derived impl because a derive would require `I: HashStable`.
+impl<CTX, I: Interner> HashStable<CTX> for BoundVariableKind<I>
+where
+    BoundRegionKind<I>: HashStable<CTX>,
+    BoundTyKind<I>: HashStable<CTX>,
+{
+    #[inline]
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        std::mem::discriminant(self).hash_stable(hcx, hasher);
+        match self {
+            BoundVariableKind::Ty(ty) => ty.hash_stable(hcx, hasher),
+            BoundVariableKind::Region(region) => region.hash_stable(hcx, hasher),
+            BoundVariableKind::Const => {}
+        }
+    }
+}
+
 #[derive_where(Clone, Copy, PartialEq, Eq, Hash; I: Interner)]
 #[cfg_attr(
     feature = "nightly",

compiler/rustc_type_ir/src/sty/mod.rs

@@ -5,7 +5,9 @@ use std::ops::{ControlFlow, Deref, Range};
 use derive_where::derive_where;
 use rustc_abi::{FieldIdx, VariantIdx};
 #[cfg(feature = "nightly")]
-use rustc_macros::HashStable_NoContext;
+use rustc_data_structures::fingerprint::Fingerprint;
+#[cfg(feature = "nightly")]
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_span::sym;
 use tracing::instrument;
 
@@ -25,7 +27,6 @@ use crate::{
 /// Use this rather than `TyKind`, whenever possible.
 #[derive_where(Copy; I: Interner, I::Interned<WithCachedTypeInfo<TyKind<I>>>: Copy)]
 #[derive_where(Clone, PartialEq, Eq, Hash; I: Interner)]
-#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
 #[rustc_diagnostic_item = "Ty"]
 #[rustc_pass_by_value]
 pub struct Ty<I: Interner>(pub I::Interned<WithCachedTypeInfo<TyKind<I>>>);
@@ -42,6 +43,21 @@ impl<I: Interner> Ty<I> {
     }
 }
 
+#[cfg(feature = "nightly")]
+impl<CTX, I: Interner> HashStable<CTX> for Ty<I> {
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        // Hashing the cached fingerprint avoids recursive trait obligations like
+        // `Ty: HashStable -> TyKind: HashStable -> Ty: HashStable`.
+        let stable_hash = self.0.stable_hash;
+        debug_assert_ne!(
+            stable_hash,
+            Fingerprint::ZERO,
+            "Ty should only be stably hashed once it has a cached stable hash",
+        );
+        stable_hash.hash_stable(hcx, hasher);
+    }
+}
+
 impl<I: Interner> fmt::Debug for Ty<I>
 where
     I::Interned<WithCachedTypeInfo<TyKind<I>>>: Deref<Target = WithCachedTypeInfo<TyKind<I>>>,