Struct rustc::ich::StableHashingContext

pub struct StableHashingContext<'gcx> { /* fields omitted */ }

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

This is the context state available during incr. comp. hashing. It contains enough information to transform DefIds and HirIds into stable DefPaths (i.e. a reference to the TyCtxt) and it holds a few caches for speeding up various things (e.g. each DefId/DefPath is only hashed once).

Methods

impl<'gcx> StableHashingContext<'gcx>

pub fn new(
    sess: &'gcx Session,
    krate: &'gcx Crate,
    definitions: &'gcx Definitions,
    cstore: &'gcx CrateStore
) -> Self

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn sess(&self) -> &'gcx Session

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn while_hashing_hir_bodies<F: FnOnce(&mut Self)>(
    &mut self,
    hash_bodies: bool,
    f: F
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn while_hashing_spans<F: FnOnce(&mut Self)>(
    &mut self,
    hash_spans: bool,
    f: F
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn with_node_id_hashing_mode<F: FnOnce(&mut Self)>(
    &mut self,
    mode: NodeIdHashingMode,
    f: F
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn def_path_hash(&self, def_id: DefId) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn local_def_path_hash(&self, def_index: DefIndex) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn node_to_hir_id(&self, node_id: NodeId) -> HirId

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn hash_bodies(&self) -> bool

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn codemap(&mut self) -> &mut CachingCodemapView<'gcx>

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn is_ignored_attr(&self, name: Symbol) -> bool

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

pub fn hash_hir_item_like<F: FnOnce(&mut Self)>(&mut self, f: F)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Trait Implementations

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WorkProductId

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for DefPathHash

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Svh

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> Clone for StableHashingContext<'gcx>

fn clone(&self) -> StableHashingContext<'gcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'gcx> StableHashingContextProvider for StableHashingContext<'gcx>

type ContextType = StableHashingContext<'gcx>

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn create_stable_hashing_context(&self) -> Self::ContextType

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> DepGraphSafe for StableHashingContext<'gcx>

impl<'gcx> HashStable<StableHashingContext<'gcx>> for BodyId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for HirId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for HirId

type KeyType = (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(
    &self,
    hcx: &StableHashingContext<'gcx>
) -> (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for NodeId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for NodeId

type KeyType = (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(
    &self,
    hcx: &StableHashingContext<'gcx>
) -> (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Span

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstFloat

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstInt

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstIsize

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstUsize

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstMathErr

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Op

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for DepKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for NativeLibraryKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for NativeLibrary

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LinkagePreference

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExternCrate

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CrateSource

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for DefId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for DefId

type KeyType = DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for LocalDefId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for LocalDefId

type KeyType = DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for CrateNum

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for CrateNum

type KeyType = DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ItemLocalId

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for ItemLocalId

type KeyType = ItemLocalId

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, _: &StableHashingContext<'gcx>) -> ItemLocalId

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ItemId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitItemId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ImplItemId

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LifetimeName

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Lifetime

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LifetimeDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Path

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PathSegment

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PathParameters

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TyParamBound

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitBoundModifier

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TyParam

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Generics

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for SyntheticTyParamKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WhereClause

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WherePredicate

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WhereBoundPredicate

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WhereRegionPredicate

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for WhereEqPredicate

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MutTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MethodSig

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TypeBinding

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Ty

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PrimTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BareFnTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExistTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Ty_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FnDecl

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FunctionRetTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitRef

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PolyTraitRef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for QPath

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MacroDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Block

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Pat

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<FieldPat>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FieldPat

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BindingAnnotation

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for RangeEnd

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PatKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BinOp_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<BinOp_>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UnOp

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<Stmt_>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Local

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<Decl_>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Decl_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Arm

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Field

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<Name>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BlockCheckMode

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UnsafeSource

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Expr

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Expr_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LocalSource

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LoopSource

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for MatchSource

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CaptureClause

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<usize>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Destination

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<Ident>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LoopIdResult

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LoopIdError

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ScopeTarget

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Ident

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitItem

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitMethod

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitItemKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ImplItem

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ImplItemKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Visibility

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Defaultness

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ImplPolarity

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Mod

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ForeignMod

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for EnumDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Variant_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<Variant_>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UseKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for StructField

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for VariantData

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Item

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Item_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitItemRef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ImplItemRef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AssociatedItemKind

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ForeignItem

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ForeignItem_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Stmt_

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Arg

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Body

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for BodyId

type KeyType = (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(
    &self,
    hcx: &StableHashingContext<'gcx>
) -> (DefPathHash, ItemLocalId)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for InlineAsmOutput

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for GlobalAsm

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for InlineAsm

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CtorKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Def

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Mutability

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for IsAuto

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Unsafety

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Constness

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for DefIndex

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for DefIndex

type KeyType = DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> DefPathHash

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Export

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for LangItem

fn hash_stable<W: StableHasherResult>(
    &self,
    _: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LanguageItems

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitCandidate

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for TraitCandidate

type KeyType = (DefPathHash, Option<(DefPathHash, ItemLocalId)>)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, hcx: &StableHashingContext<'gcx>) -> Self::KeyType

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Freevar

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for GeneratorLayout<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for SourceInfo

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Mutability

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BorrowKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LocalKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LocalDecl<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UpvarDecl

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BasicBlockData<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UnsafetyViolation

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UnsafetyCheckResult

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for UnsafetyViolationKind

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Terminator<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for ClearCrossCrate<T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Local

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for BasicBlock

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Field

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for VisibilityScope

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Promoted

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TerminatorKind<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AssertMessage<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Statement<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for StatementKind<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for ValidationOperand<'gcx, T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ValidationOp

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Place<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, B, V, T> HashStable<StableHashingContext<'gcx>> for Projection<'gcx, B, V, T> where
    B: HashStable<StableHashingContext<'gcx>>,
    V: HashStable<StableHashingContext<'gcx>>,
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, V, T> HashStable<StableHashingContext<'gcx>> for ProjectionElem<'gcx, V, T> where
    V: HashStable<StableHashingContext<'gcx>>,
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for VisibilityScopeData

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for VisibilityScopeInfo

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Safety

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Operand<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Rvalue<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CastKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AggregateKind<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BinOp

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UnOp

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for NullOp

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Constant<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Literal<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Location

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ClosureRegionRequirements

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ClosureOutlivesRequirement

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PathKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for PanicStrategy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for &'gcx Slice<T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Kind<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for RegionKind

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for RegionVid

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AutoBorrow<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Adjust<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Adjustment<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for OverloadedDeref<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UpvarBorrow<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UpvarId

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BorrowKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for UpvarCapture<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for GenSig<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FnSig<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for Binder<T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ClosureKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Visibility

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitRef<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TraitPredicate<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for EquatePredicate<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for SubtypePredicate<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, A, B> HashStable<StableHashingContext<'gcx>> for OutlivesPredicate<A, B> where
    A: HashStable<StableHashingContext<'gcx>>,
    B: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ProjectionPredicate<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ProjectionTy<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Predicate<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AdtFlags

fn hash_stable<W: StableHasherResult>(
    &self,
    _: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for VariantDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for VariantDiscr

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FieldDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ConstVal<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ByteArray<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Const<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ConstEvalErr<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ErrKind<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ClosureSubsts<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for GeneratorInterior<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for GenericPredicates<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Variance

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CustomCoerceUnsized

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Generics

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for RegionParameterDef

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TypeParameterDef

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for Set1<T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LifetimeDefOrigin

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Region

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for DebruijnIndex

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CastKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FirstStatementIndex

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Scope

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for Scope

type KeyType = Scope

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, _: &StableHashingContext<'gcx>) -> Scope

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BlockRemainder

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CoerceUnsizedInfo

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FreeRegion

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BoundRegion

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TypeVariants<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ParamTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TypeAndMut<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ExistentialPredicate<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExistentialTraitRef<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExistentialProjection<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Instance<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for InstanceDef<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitDef

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Destructor

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for DtorckConstraint<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for CrateVariancesMap

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AssociatedItem

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AssociatedKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AssociatedItemContainer

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for Steal<T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ParamEnv<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Reveal

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AccessLevel

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AccessLevels

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CrateInherentImpls

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CompileIncomplete

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ErrorReported

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ReachableSet

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for Vtable<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableImplData<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableAutoImplData<N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableObjectData<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableBuiltinData<N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableClosureData<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableFnPointerData<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, N> HashStable<StableHashingContext<'gcx>> for VtableGeneratorData<'gcx, N> where
    N: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for InternedString

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for InternedString

type KeyType = InternedString

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, _: &StableHashingContext<'gcx>) -> InternedString

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Name

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> ToStableHashKey<StableHashingContext<'gcx>> for Name

type KeyType = InternedString

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, _: &StableHashingContext<'gcx>) -> InternedString

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AsmDialect

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MacroKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Abi

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Deprecation

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Stability

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for StabilityLevel

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for RustcDeprecation

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for RustcConstUnstable

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for IntType

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LitIntType

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<LitKind>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LitKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for IntTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for UintTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FloatTy

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Unsafety

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Constness

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Defaultness

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Lifetime

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for StrStyle

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for AttrStyle

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for [Attribute]

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Attribute

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TokenTree

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TokenStream

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Spanned<NestedMetaItemKind>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for NestedMetaItemKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MetaItem

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for MetaItemKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExpnInfo

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for NameAndSpan

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ExpnFormat

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CompilerDesugaringKind

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FileName

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for FileMap

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for FreeRegionMap<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for LintLevelMap

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Level

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LintSource

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for BorrowCheckResult

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for SymbolExportLevel

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for ScopeTree

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ResolveLifetimes

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for DeprecationEntry

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Index<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for TransItem<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Linkage

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Visibility

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CodegenUnit<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'tcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Stats

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Mir<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Static<'tcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for OutputType

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> ToStableHashKey<StableHashingContext<'tcx>> for OutputType

type KeyType = OutputType

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

fn to_stable_hash_key(&self, _: &StableHashingContext<'tcx>) -> Self::KeyType

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for OutputTypes

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for OutputFilenames

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for CrateDisambiguator

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Graph

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for BindingMode

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, D> HashStable<StableHashingContext<'gcx>> for SimplifiedTypeGen<D> where
    D: Copy + Debug + Ord + Eq + Hash + HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Variants

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for FieldPlacement

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Abi

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for Scalar

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for LayoutDetails

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Integer

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Primitive

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Align

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for Size

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for LayoutError<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TraitImpls

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TypeckTables<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for TyS<'gcx>

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx, T> HashStable<StableHashingContext<'gcx>> for ParamEnvAnd<'gcx, T> where
    T: HashStable<StableHashingContext<'gcx>>, 

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'gcx> HashStable<StableHashingContext<'gcx>> for AdtDef

fn hash_stable<W: StableHasherResult>(
    &self,
    hcx: &mut StableHashingContext<'gcx>,
    hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ReprFlags

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for ReprOptions

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

impl<'tcx> HashStable<StableHashingContext<'tcx>> for SymbolName

fn hash_stable<W: StableHasherResult>(
    &self,
    __ctx: &mut StableHashingContext<'tcx>,
    __hasher: &mut StableHasher<W>
)

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?