Struct rustc_span::def_id::DefPathHash
source · pub struct DefPathHash(pub Fingerprint);
Expand description
A DefPathHash
is a fixed-size representation of a DefPath
that is
stable across crate and compilation session boundaries. It consists of two
separate 64-bit hashes. The first uniquely identifies the crate this
DefPathHash
originates from (see StableCrateId), and the second
uniquely identifies the corresponding DefPath
within that crate. Together
they form a unique identifier within an entire crate graph.
There is a very small chance of hash collisions, which would mean that two
different DefPath
s map to the same DefPathHash
. Proceeding compilation
with such a hash collision would very probably lead to an ICE, and in the
worst case lead to a silent mis-compilation. The compiler therefore actively
and exhaustively checks for such hash collisions and aborts compilation if
it finds one.
DefPathHash
uses 64-bit hashes for both the crate-id part and the
crate-internal part, even though it is likely that there are many more
LocalDefId
s in a single crate than there are individual crates in a crate
graph. Since we use the same number of bits in both cases, the collision
probability for the crate-local part will be quite a bit higher (though
still very small).
This imbalance is not by accident: A hash collision in the
crate-local part of a DefPathHash
will be detected and reported while
compiling the crate in question. Such a collision does not depend on
outside factors and can be easily fixed by the crate maintainer (e.g. by
renaming the item in question or by bumping the crate version in a harmless
way).
A collision between crate-id hashes on the other hand is harder to fix because it depends on the set of crates in the entire crate graph of a compilation session. Again, using the same crate with a different version number would fix the issue with a high probability – but that might be easier said then done if the crates in questions are dependencies of third-party crates.
That being said, given a high quality hash function, the collision
probabilities in question are very small. For example, for a big crate like
rustc_middle
(with ~50000 LocalDefId
s as of the time of writing) there
is a probability of roughly 1 in 14,750,000,000 of a crate-internal
collision occurring. For a big crate graph with 1000 crates in it, there is
a probability of 1 in 36,890,000,000,000 of a StableCrateId
collision.
Tuple Fields§
§0: Fingerprint
Implementations§
source§impl DefPathHash
impl DefPathHash
sourcepub fn stable_crate_id(&self) -> StableCrateId
pub fn stable_crate_id(&self) -> StableCrateId
Returns the StableCrateId identifying the crate this DefPathHash originates from.
sourcepub fn local_hash(&self) -> Hash64
pub fn local_hash(&self) -> Hash64
Returns the crate-local part of the DefPathHash.
Used for tests.
sourcepub fn new(stable_crate_id: StableCrateId, local_hash: Hash64) -> DefPathHash
pub fn new(stable_crate_id: StableCrateId, local_hash: Hash64) -> DefPathHash
Builds a new DefPathHash with the given StableCrateId and
local_hash
, where local_hash
must be unique within its crate.
Trait Implementations§
source§impl Clone for DefPathHash
impl Clone for DefPathHash
source§fn clone(&self) -> DefPathHash
fn clone(&self) -> DefPathHash
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl Debug for DefPathHash
impl Debug for DefPathHash
source§impl<__D: Decoder> Decodable<__D> for DefPathHash
impl<__D: Decoder> Decodable<__D> for DefPathHash
source§impl Default for DefPathHash
impl Default for DefPathHash
source§impl<__E: Encoder> Encodable<__E> for DefPathHash
impl<__E: Encoder> Encodable<__E> for DefPathHash
source§impl Hash for DefPathHash
impl Hash for DefPathHash
source§impl<__CTX> HashStable<__CTX> for DefPathHashwhere
__CTX: HashStableContext,
impl<__CTX> HashStable<__CTX> for DefPathHashwhere __CTX: HashStableContext,
fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)
source§impl Ord for DefPathHash
impl Ord for DefPathHash
source§fn cmp(&self, other: &DefPathHash) -> Ordering
fn cmp(&self, other: &DefPathHash) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere Self: Sized,
source§impl PartialEq<DefPathHash> for DefPathHash
impl PartialEq<DefPathHash> for DefPathHash
source§fn eq(&self, other: &DefPathHash) -> bool
fn eq(&self, other: &DefPathHash) -> bool
self
and other
values to be equal, and is used
by ==
.source§impl PartialOrd<DefPathHash> for DefPathHash
impl PartialOrd<DefPathHash> for DefPathHash
source§fn partial_cmp(&self, other: &DefPathHash) -> Option<Ordering>
fn partial_cmp(&self, other: &DefPathHash) -> Option<Ordering>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl Copy for DefPathHash
impl Eq for DefPathHash
impl StructuralEq for DefPathHash
impl StructuralPartialEq for DefPathHash
Auto Trait Implementations§
impl RefUnwindSafe for DefPathHash
impl Send for DefPathHash
impl Sync for DefPathHash
impl Unpin for DefPathHash
impl UnwindSafe for DefPathHash
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 16 bytes