Trait StableHash 

pub trait StableHash {
    // Required method
    fn stable_hash<Hcx: StableHashCtxt>(
        &self,
        hcx: &mut Hcx,
        hasher: &mut StableHasher,
    );
}

Something that implements StableHash can be hashed in a way that is stable across multiple compilation sessions.

Note that StableHash imposes rather more strict requirements than usual hash functions:

• Stable hashes are sometimes used as identifiers. Therefore they must conform to the corresponding PartialEq implementations:

  • x == y implies stable_hash(x) == stable_hash(y), and
  • x != y implies stable_hash(x) != stable_hash(y).

  That second condition is usually not required for hash functions (e.g. Hash). In practice this means that stable_hash must feed any information into the hasher that a PartialEq comparison takes into account. See #49300 for an example where violating this invariant has caused trouble in the past.

• stable_hash() must be independent of the current compilation session. E.g. they must not hash memory addresses or other things that are “randomly” assigned per compilation session.

• stable_hash() must be independent of the host architecture. The StableHasher takes care of endianness and isize/usize platform differences.

Consistency across compiler stages

Because the stage1 compiler is built against the bootstrap stdlib, but the stage2 compiler uses in-tree stdlib, implementations of StableHash must not rely on Hash impls that were provided or derived by the standard library. Doing so leads to weird bugs and CI failures that can block changes to those stdlib hash impls.

(Unfortunately, as of late 2026 we have many stable-hash impls that do leak details of stdlib hash impls.)

See https://github.com/rust-lang/rust/pull/164458 for more context.

Required Methods

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl StableHash for !

fn stable_hash<Hcx>(&self, _hcx: &mut Hcx, _hasher: &mut StableHasher)

impl StableHash for ()

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for Hash64

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for Hash128

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for Ordering

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for OsStr

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for Path

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for PathBuf

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for String

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for [u8]

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for bool

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for char

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for f32

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for f64

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for i8

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for i16

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for i32

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for i64

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for i128

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for isize

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for str

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl StableHash for u8

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for u16

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for u32

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for u64

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for u128

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl StableHash for usize

fn stable_hash<Hcx>(&self, _: &mut Hcx, hasher: &mut StableHasher)

impl<'a, T> StableHash for &'a T

where T: StableHash + ?Sized,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<A, const N: usize> StableHash for SmallVec<[A; N]>

where A: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<I: Idx, T> StableHash for IndexSlice<I, T>

where T: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<I: Idx, T> StableHash for IndexVec<I, T>

where T: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<I: Idx> StableHash for DenseBitSet<I>

fn stable_hash<Hcx: StableHashCtxt>( &self, _hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<K, R> StableHash for IndexSet<K, R>

where K: StableHash + Eq + Hash, R: BuildHasher,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<K, V, R> StableHash for IndexMap<K, V, R>

where K: StableHash + Eq + Hash, V: StableHash, R: BuildHasher,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<K, V> !StableHash for HashMap<K, V>

impl<K, V> StableHash for BTreeMap<K, V>

where K: StableHash + StableOrd, V: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<K> StableHash for BTreeSet<K>

where K: StableHash + StableOrd,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<R: Idx, C: Idx> StableHash for BitMatrix<R, C>

fn stable_hash<Hcx: StableHashCtxt>( &self, _hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T1, T2, T3, T4> StableHash for (T1, T2, T3, T4)

where T1: StableHash, T2: StableHash, T3: StableHash, T4: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T1, T2, T3> StableHash for (T1, T2, T3)

where T1: StableHash, T2: StableHash, T3: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T1, T2> StableHash for Result<T1, T2>

where T1: StableHash, T2: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T1: StableHash, T2: StableHash> StableHash for (T1, T2)

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T1: StableHash> StableHash for (T1,)

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: ?Sized + StableHash> StableHash for Arc<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: ?Sized + StableHash> StableHash for Box<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: ?Sized + StableHash> StableHash for Rc<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: StableHash + ZeroablePrimitive> StableHash for NonZero<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: StableHash> StableHash for ThinVec<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: StableHash> StableHash for Vec<T>

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T: StableHash> StableHash for [T]

default fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T> !StableHash for Discriminant<T>

There is no way to stable-hash a Discriminant without leaking unstable details of how the host compiler chooses and hashes discriminants.

That would be bad, because stable hashes must be consistent between the stage1 compiler (built with the bootstrap compiler/stdlib) and the stage2 compiler (built with the in-tree compiler/stdlib).

See https://github.com/rust-lang/rust/issues/164734 for more context.

If you need to manually stable-hash a discriminant, instead derive StableHash on a dedicated “tag” enum, and then hash the appropriate tag for each variant. For an example, see the impl of StableHash for Result.

impl<T> StableHash for Option<T>

where T: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<T> StableHash for PhantomData<T>

fn stable_hash<Hcx>(&self, _hcx: &mut Hcx, _hasher: &mut StableHasher)

impl<T> StableHash for RangeInclusive<T>

where T: StableHash,

fn stable_hash<Hcx: StableHashCtxt>( &self, hcx: &mut Hcx, hasher: &mut StableHasher, )

impl<V> !StableHash for HashSet<V>

Implementors

impl StableHash for Fingerprint

impl StableHash for Pu128

impl StableHash for Svh

impl<'a, P, T> StableHash for TaggedRef<'a, P, T>

where P: StableHash + Aligned + ?Sized, T: Tag + StableHash,

impl<I, K, V> StableHash for SortedIndexMultiMap<I, K, V>

where I: StableHash + Idx, K: StableHash, V: StableHash,

impl<K: Hash + Eq + StableHash, V: StableHash> StableHash for UnordMap<K, V>

impl<K: StableHash + StableOrd, V: StableHash> StableHash for SortedMap<K, V>

impl<T: StableHash> StableHash for Steal<T>

impl<T> StableHash for Interned<'_, T>

where T: StableHash,

impl<V: Hash + Eq + StableHash> StableHash for UnordBag<V>

impl<V: Hash + Eq + StableHash> StableHash for UnordSet<V>