[−][src]Struct rustc::ich::StableHashingContext

pub struct StableHashingContext<'a> {
    sess: &'a Session,
    definitions: &'a Definitions,
    cstore: &'a dyn CrateStore,
    body_resolver: BodyResolver<'a>,
    hash_spans: bool,
    hash_bodies: bool,
    node_id_hashing_mode: NodeIdHashingMode,
    raw_source_map: &'a SourceMap,
    caching_source_map: Option<CachingSourceMapView<'a>>,
}

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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).

Fields

sess: &'a Session

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

definitions: &'a Definitions

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

cstore: &'a dyn CrateStore

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

body_resolver: BodyResolver<'a>

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

hash_spans: bool

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

hash_bodies: bool

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

node_id_hashing_mode: NodeIdHashingMode

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

raw_source_map: &'a SourceMap

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

caching_source_map: Option<CachingSourceMapView<'a>>

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Methods

`impl<'a> StableHashingContext<'a>`[src]

`pub fn new( sess: &'a Session, krate: &'a Crate, definitions: &'a Definitions, cstore: &'a dyn CrateStore ) -> Self`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn sess(&self) -> &'a Session`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn def_path_hash(&self, def_id: DefId) -> DefPathHash`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn local_def_path_hash(&self, def_index: DefIndex) -> DefPathHash`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn node_to_hir_id(&self, node_id: NodeId) -> HirId`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn hash_bodies(&self) -> bool`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn source_map(&mut self) -> &mut CachingSourceMapView<'a>`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

`pub fn is_ignored_attr(&self, name: Symbol) -> bool`[src]

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

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

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

Trait Implementations

`impl<'a> DepGraphSafe for StableHashingContext<'a>`[src]

`impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a>`[src]

`fn get_stable_hashing_context(&self) -> StableHashingContext<'a>`[src]

`impl<'a> Clone for StableHashingContext<'a>`[src]

`fn clone(&self) -> StableHashingContext<'a>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from source. Read more

`impl<'a> HashStable<StableHashingContext<'a>> for WorkProductId`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CtorOf`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CtorKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NonMacroAttrKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for DefKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Id> HashStable<StableHashingContext<'ctx>> for Res<Id> where Id: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Id> HashStable<StableHashingContext<'ctx>> for Export<Id> where Id: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'hir, T> HashStable<StableHashingContext<'hir>> for HirItemLike<T> where T: HashStable<StableHashingContext<'hir>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DefPathHash`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ItemLocalId`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Lifetime`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ParamName`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LifetimeName`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Path`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PathSegment`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ConstArg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericArg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericArgs`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitBoundModifier`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericBound`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LifetimeParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericParam`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Generics`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SyntheticTyParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereClause`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WherePredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereBoundPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereRegionPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereEqPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MacroDef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Block`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Pat`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FieldPat`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BindingAnnotation`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for RangeEnd`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PatKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Mutability`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BinOpKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnOp`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for StmtKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Local`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Arm`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Guard`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Field`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BlockCheckMode`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnsafeSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GeneratorKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AnonConst`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ExprKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for QPath`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LocalSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MatchSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LoopSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LoopIdError`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Destination`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GeneratorMovability`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for YieldSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CaptureClause`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MutTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MethodSig`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitMethod`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ImplItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TypeBinding`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TypeBindingKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PrimTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BareFnTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for OpaqueTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for OpaqueTyOrigin`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TyKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for InlineAsmOutput`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for InlineAsm`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Arg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FnDecl`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ImplicitSelfKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for IsAuto`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for IsAsync`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Unsafety`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Constness`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Defaultness`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ImplPolarity`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FunctionRetTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ForeignMod`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GlobalAsm`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for EnumDef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Variant`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UseKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitRef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PolyTraitRef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for StructField`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for VariantData`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FnHeader`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitItemRef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ImplItemRef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AssocItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ForeignItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ForeignItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Upvar`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CodegenFnAttrs`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CodegenFnAttrFlags`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BodyId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for HirId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for NodeId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Span`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DelimSpan`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DefId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LocalDefId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for CrateNum`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ItemId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TraitItemId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ImplItemId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Label`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Ty`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<BinOpKind>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Stmt`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<Name>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Expr`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<usize>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Ident`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TraitItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ImplItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for CrateSugar`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for VisibilityKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<VisibilityKind>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Mod`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<Variant>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Item`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Body`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DefIndex`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LangItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, _: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TraitCandidate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'hir> HashStable<StableHashingContext<'hir>> for InlineAttr`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher<W> )`[src]

`impl<'hir> HashStable<StableHashingContext<'hir>> for OptimizeAttr`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for PanicStrategy`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx, T> HashStable<StableHashingContext<'a>> for &'tcx List<T> where T: HashStable<StableHashingContext<'a>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Kind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for RegionKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for RegionVid`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ConstVid<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx> HashStable<StableHashingContext<'tcx>> for BoundVar`[src]

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

`impl<'a, T> HashStable<StableHashingContext<'a>> for Binder<T> where T: HashStable<StableHashingContext<'a>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for AllocId`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Allocation`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Mutability`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TyVid`[src]

`fn hash_stable<W: StableHasherResult>( &self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for IntVid`[src]

`fn hash_stable<W: StableHasherResult>( &self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for FloatVid`[src]

`fn hash_stable<W: StableHasherResult>( &self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher<W> )`[src]

`impl<'a, T> HashStable<StableHashingContext<'a>> for Steal<T> where T: HashStable<StableHashingContext<'a>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for AccessLevels`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for InternedString`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LocalInternedString`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Name`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for AsmDialect`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for MacroKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Abi`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Deprecation`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Stability`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Edition`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for StabilityLevel`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for RustcDeprecation`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for IntType`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LitIntType`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Lit`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LitKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Spanned<LitKind>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for IntTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for UintTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for FloatTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Unsafety`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Constness`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Defaultness`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Lifetime`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for StrStyle`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for AttrStyle`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for [Attribute]`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Path`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Attribute`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TokenTree`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TokenStream`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LitKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Lit`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TokenKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Token`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for NestedMetaItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for MetaItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for MetaItemKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Transparency`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ExpnData`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ExpnKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DesugaringKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for FileName`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for SourceFile`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx> HashStable<StableHashingContext<'tcx>> for Features`[src]

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

`impl<'tcx, 'ctx, V> HashStable<StableHashingContext<'ctx>> for Canonical<'tcx, V> where V: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for CanonicalVarValues<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CanonicalVarInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CanonicalVarKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CanonicalTyVarKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, R> HashStable<StableHashingContext<'ctx>> for QueryResponse<'tcx, R> where R: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for QueryRegionConstraints<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Certainty`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for FreeRegionMap<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for MemberConstraint<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Level`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LintSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LintLevelMap`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for SignalledError`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BorrowCheckResult`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CrateSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for DepKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LinkagePreference`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NativeLibraryKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NativeLibrary`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ForeignModule`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ExternCrate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ExternCrateSource`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for SymbolExportLevel`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ExportedSymbol<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LibFeatures`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LanguageItems`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AccessLevel`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ReachableSet`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Scope`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ScopeData`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FirstStatementIndex`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for YieldData`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ScopeTree`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LifetimeDefOrigin`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Region`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, T> HashStable<StableHashingContext<'ctx>> for Set1<T> where T: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ResolveLifetimes`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DeprecationEntry`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Index<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Cache`[src]

`fn hash_stable<W: StableHasherResult>( &self, _: &mut StableHashingContext<'a>, _: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ErrorHandled`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for FrameInfo<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, O> HashStable<StableHashingContext<'ctx>> for PanicInfo<O> where O: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InvalidProgramInfo<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UndefinedBehaviorInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for UnsupportedOpInfo<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ResourceExhaustionInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InterpError<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for RawConst<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ConstValue<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Tag, Id> HashStable<StableHashingContext<'ctx>> for Scalar<Tag, Id> where Tag: HashStable<StableHashingContext<'ctx>>, Id: HashStable<StableHashingContext<'ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ScalarMaybeUndef`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for UndefMask`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CheckInAllocMsg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Tag, Id> HashStable<StableHashingContext<'ctx>> for Pointer<Tag, Id> where Id: HashStable<StableHashingContext<'ctx>>, Tag: HashStable<StableHashingContext<'ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GlobalId<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GlobalAlloc<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for MonoItem<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Linkage`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Visibility`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for CodegenUnit<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Safety`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Body<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx, T> HashStable<StableHashingContext<'ctx>> for ClearCrossCrate<T> where T: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SourceInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Mutability`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BorrowKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Local`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LocalKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for VarBindingForm<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for ImplicitSelfKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for MirPhase`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for BindingForm<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BlockTailInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for LocalDecl<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UpvarDebuginfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BasicBlock`

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

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for BasicBlockData<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Terminator<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for TerminatorKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Statement<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for StatementKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for RetagKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FakeReadCause`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InlineAsm<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Place<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for PlaceBase<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for StaticKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Static<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Projection<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, V, T> HashStable<StableHashingContext<'ctx>> for ProjectionElem<V, T> where T: HashStable<StableHashingContext<'ctx>>, V: HashStable<StableHashingContext<'ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Field`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SourceScope`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SourceScopeData`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SourceScopeLocalData`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Operand<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Rvalue<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CastKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for AggregateKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BinOp`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NullOp`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnOp`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Constant<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UserTypeProjections`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UserTypeProjection`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Promoted`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Location`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnsafetyViolationKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnsafetyViolation`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UnsafetyCheckResult`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GeneratorSavedLocal`

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

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GeneratorLayout<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for BorrowCheckResult<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ClosureRegionRequirements<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ClosureOutlivesRequirement<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ConstraintCategory`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ClosureOutlivesSubject<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PathKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Reveal`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for EvaluationResult`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for OverflowError`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Children`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Graph`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for DropckOutlivesResult<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for DtorckConstraint<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for MethodAutoderefBadTy<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for MethodAutoderefStepsResult<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for CandidateStep<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for NormalizationResult<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for OutlivesBound<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for AscribeUserType<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Eq<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ImpliedOutlivesBounds<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, T> HashStable<StableHashingContext<'a>> for Normalize<T> where T: HashStable<StableHashingContext<'a>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for DropckOutlives<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for ProvePredicate<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Subtype<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for NoSolution`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for WhereClause<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for WellFormed<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for FromEnv<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for DomainGoal<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for QuantifierKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GoalKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Clause<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ProgramClause<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ProgramClauseCategory`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Environment<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, G> HashStable<StableHashingContext<'ctx>> for InEnvironment<'tcx, G> where G: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for Vtable<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableImplData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableGeneratorData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableClosureData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableAutoImplData<N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableBuiltinData<N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableObjectData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableFnPointerData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx, N> HashStable<StableHashingContext<'ctx>> for VtableTraitAliasData<'tcx, N> where N: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PointerCast`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Adjustment<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Adjust<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for OverloadedDeref<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AllowTwoPhase`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AutoBorrowMutability`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for AutoBorrow<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CoerceUnsizedInfo`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CustomCoerceUnsized`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BindingMode`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CastKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, D> HashStable<StableHashingContext<'a>> for SimplifiedTypeGen<D> where D: Copy + Debug + Ord + Eq + Hash + HashStable<StableHashingContext<'a>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Variants`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DiscriminantKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for FieldPlacement`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for VariantIdx`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Abi`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Scalar`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Niche`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for LayoutDetails`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Integer`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for Primitive`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for AbiAndPrefAlign`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx> HashStable<StableHashingContext<'tcx>> for Align`[src]

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

`impl<'tcx> HashStable<StableHashingContext<'tcx>> for Size`[src]

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

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for LayoutError<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Query<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for UnpackedKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for UserSubsts<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for UserSelfTy<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitDef`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for TraitImpls`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NeedsDrop`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ResolvedOpaqueTy<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for UserTypeAnnotationIndex`

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

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for CanonicalUserTypeAnnotation<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for UserType<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Instance<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InstanceDef<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for TypeAndMut<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for FreeRegion`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for BoundRegion`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for TyKind<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ClosureSubsts<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GeneratorSubsts<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ExistentialPredicate<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for TraitRef<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ExistentialTraitRef<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ProjectionTy<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for GenSig<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for FnSig<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ParamTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ParamConst`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for InferTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BoundTy`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for BoundTyKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ExistentialProjection<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DebruijnIndex`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for Const<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for InferConst<'tcx>`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AssocItemContainer`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AssocItem`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for AssocKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Visibility`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Variance`[src]

`fn hash_stable<__W:`

[−][src]Struct rustc::ich::StableHashingContext

Fields

Methods

impl<'a> StableHashingContext<'a>[src]

pub fn new( sess: &'a Session, krate: &'a Crate, definitions: &'a Definitions, cstore: &'a dyn CrateStore) -> Self[src]

pub fn sess(&self) -> &'a Session[src]

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

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

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

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

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

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

pub fn hash_bodies(&self) -> bool[src]

pub fn source_map(&mut self) -> &mut CachingSourceMapView<'a>[src]

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

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

Trait Implementations

impl<'a> DepGraphSafe for StableHashingContext<'a>[src]

impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a>[src]

fn get_stable_hashing_context(&self) -> StableHashingContext<'a>[src]

impl<'a> Clone for StableHashingContext<'a>[src]

fn clone(&self) -> StableHashingContext<'a>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<'a> HashStable<StableHashingContext<'a>> for WorkProductId[src]

fn hash_stable<W: StableHasherResult>( &self, __ctx: &mut StableHashingContext<'a>, __hasher: &mut StableHasher<W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for CtorOf[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for CtorKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for NonMacroAttrKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for DefKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx, Id> HashStable<StableHashingContext<'__ctx>> for Res<Id> where Id: HashStable<StableHashingContext<'__ctx>>, [src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx, Id> HashStable<StableHashingContext<'__ctx>> for Export<Id> where Id: HashStable<StableHashingContext<'__ctx>>, [src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'hir, T> HashStable<StableHashingContext<'hir>> for HirItemLike<T> where T: HashStable<StableHashingContext<'hir>>, [src]

fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher<W>)[src]

impl<'a> HashStable<StableHashingContext<'a>> for DefPathHash[src]

fn hash_stable<W: StableHasherResult>( &self, __ctx: &mut StableHashingContext<'a>, __hasher: &mut StableHasher<W>)[src]

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

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

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Lifetime[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for ParamName[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for LifetimeName[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Path[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for PathSegment[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for ConstArg[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericArg[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericArgs[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for TraitBoundModifier[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericBound[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for LifetimeParamKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericParamKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericParam[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Generics[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for SyntheticTyParamKind[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WhereClause[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WherePredicate[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WhereBoundPredicate[src]

fn hash_stable<__W: StableHasherResult>( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher<__W>)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WhereRegionPredicate[src]

`impl<'a> StableHashingContext<'a>`[src]

`pub fn new( sess: &'a Session, krate: &'a Crate, definitions: &'a Definitions, cstore: &'a dyn CrateStore ) -> Self`[src]

`pub fn sess(&self) -> &'a Session`[src]

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

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

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

`pub fn def_path_hash(&self, def_id: DefId) -> DefPathHash`[src]

`pub fn local_def_path_hash(&self, def_index: DefIndex) -> DefPathHash`[src]

`pub fn node_to_hir_id(&self, node_id: NodeId) -> HirId`[src]

`pub fn hash_bodies(&self) -> bool`[src]

`pub fn source_map(&mut self) -> &mut CachingSourceMapView<'a>`[src]

`pub fn is_ignored_attr(&self, name: Symbol) -> bool`[src]

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

`impl<'a> DepGraphSafe for StableHashingContext<'a>`[src]

`impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a>`[src]

`fn get_stable_hashing_context(&self) -> StableHashingContext<'a>`[src]

`impl<'a> Clone for StableHashingContext<'a>`[src]

`fn clone(&self) -> StableHashingContext<'a>`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> HashStable<StableHashingContext<'a>> for WorkProductId`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CtorOf`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for CtorKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for NonMacroAttrKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for DefKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Id> HashStable<StableHashingContext<'ctx>> for Res<Id> where Id: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx, Id> HashStable<StableHashingContext<'ctx>> for Export<Id> where Id: HashStable<StableHashingContext<'__ctx>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'hir, T> HashStable<StableHashingContext<'hir>> for HirItemLike<T> where T: HashStable<StableHashingContext<'hir>>,` [src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher<W> )`[src]

`impl<'a> HashStable<StableHashingContext<'a>> for DefPathHash`[src]

`fn hash_stable<W: StableHasherResult>( &self, ctx: &mut StableHashingContext<'a>, hasher: &mut StableHasher<W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ItemLocalId`

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Lifetime`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ParamName`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LifetimeName`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Path`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for PathSegment`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for ConstArg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericArg`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericArgs`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for TraitBoundModifier`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericBound`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for LifetimeParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for GenericParam`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for Generics`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for SyntheticTyParamKind`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereClause`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WherePredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereBoundPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereRegionPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereEqPredicate`[src]

`fn hash_stable<W: StableHasherResult>( &self, hcx: &mut StableHashingContext<'ctx>, hasher: &mut StableHasher<__W> )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MacroDef`[src]