[−][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.

The krate here is only used for mapping BodyIds to Bodys. Don't use it for anything else or you'll run the risk of leaking data out of the tracking system.

`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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'a, Tag> HashStable<StableHashingContext<'a>> for Relocations<Tag> where Tag: HashStable<StableHashingContext<'a>>,` [src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[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( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[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( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[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( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'ctx, A, B> HashStable<StableHashingContext<'ctx>> for OutlivesPredicate<A, B> where A: HashStable<StableHashingContext<'ctx>>, B: HashStable<StableHashingContext<'ctx>>,` [src]

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`type KeyType = (DefPathHash, ItemLocalId)`

⚙️ 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.

`fn to_stable_hash_key( &self, hcx: &StableHashingContext<'a> ) -> (DefPathHash, ItemLocalId)`[src]

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

`type KeyType = (DefPathHash, ItemLocalId)`

⚙️ 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.

`fn to_stable_hash_key( &self, hcx: &StableHashingContext<'a> ) -> (DefPathHash, ItemLocalId)`[src]

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

`type KeyType = DefPathHash`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash`[src]

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

`type KeyType = DefPathHash`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash`[src]

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

`type KeyType = DefPathHash`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash`[src]

`impl<'a> ToStableHashKey<StableHashingContext<'a>> for ItemLocalId`[src]

`type KeyType = ItemLocalId`

⚙️ 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.

`fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> ItemLocalId`[src]

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

`type KeyType = (DefPathHash, ItemLocalId)`

⚙️ 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.

`fn to_stable_hash_key( &self, hcx: &StableHashingContext<'a> ) -> (DefPathHash, ItemLocalId)`[src]

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

`type KeyType = DefPathHash`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> DefPathHash`[src]

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

`type KeyType = (DefPathHash, SmallVec<[(DefPathHash, ItemLocalId); 1]>)`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> Self::KeyType`[src]

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

`type KeyType = Fingerprint`

⚙️ 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.

`fn to_stable_hash_key(&self, hcx: &StableHashingContext<'a>) -> Fingerprint`[src]

`impl<'a> ToStableHashKey<StableHashingContext<'a>> for Scope`[src]

`type KeyType = Scope`

⚙️ 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.

`fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> Scope`[src]

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

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

`fn byte_pos_to_line_and_col( &mut self, byte: BytePos ) -> Option<(Lrc<SourceFile>, usize, BytePos)>`[src]

`impl<'ctx> HashStableContext for StableHashingContext<'ctx>`[src]

Auto Trait Implementations

`impl<'a> !Send for StableHashingContext<'a>`

`impl<'a> !Sync for StableHashingContext<'a>`

`impl<'a> Unpin for StableHashingContext<'a>`

`impl<'a> !UnwindSafe for StableHashingContext<'a>`

`impl<'a> !RefUnwindSafe for StableHashingContext<'a>`

Blanket Implementations

`impl<T> MaybeResult<T> for T`[src]

`type Error = !`

⚙️ 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.

`fn from(Result<T, <T as MaybeResult<T>>::Error>) -> T`[src]

`fn to_result(Self) -> Result<T, <T as MaybeResult<T>>::Error>`[src]

`impl<'a, T> Captures<'a> for T where T: ?Sized,` [src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = !`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Erased for T`[src]

`impl<E> SpecializationError for E`[src]

`default fn not_found<S, T>( trait_name: &'static str, method_name: &'static str ) -> E where T: ?Sized,` [src]

[−][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<'__ctx> HashStable<StableHashingContext<'__ctx>> for WorkProductId[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for CtorOf[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for CtorKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for NonMacroAttrKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for DefKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

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

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

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

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

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

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

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for DefPathHash[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

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

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

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Lifetime[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for ParamName[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for LifetimeName[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Path[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for PathSegment[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for ConstArg[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericArg[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericArgs[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for TraitBoundModifier[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericBound[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for LifetimeParamKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericParamKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for GenericParam[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Generics[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for SyntheticTyParamKind[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WhereClause[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WherePredicate[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[src]

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for WhereBoundPredicate[src]

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher)[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<'ctx> HashStable<StableHashingContext<'ctx>> for WorkProductId`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereClause`[src]

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WherePredicate`[src]

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereBoundPredicate`[src]

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereRegionPredicate`[src]

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for WhereEqPredicate`[src]

`fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )`[src]

`impl<'ctx> HashStable<StableHashingContext<'ctx>> for MacroDef`[src]