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
sourceimpl 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) -> u64
pub fn local_hash(&self) -> u64
Returns the crate-local part of the DefPathHash.
Used for tests.
sourcepub fn new(stable_crate_id: StableCrateId, local_hash: u64) -> DefPathHash
pub fn new(stable_crate_id: StableCrateId, local_hash: u64) -> DefPathHash
Builds a new DefPathHash with the given StableCrateId and
local_hash
, where local_hash
must be unique within its crate.
Trait Implementations
sourceimpl Borrow<Fingerprint> for DefPathHash
impl Borrow<Fingerprint> for DefPathHash
sourcefn borrow(&self) -> &Fingerprint
fn borrow(&self) -> &Fingerprint
sourceimpl Clone for DefPathHash
impl Clone for DefPathHash
sourcefn clone(&self) -> DefPathHash
fn clone(&self) -> DefPathHash
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl Debug for DefPathHash
impl Debug for DefPathHash
sourceimpl Hash for DefPathHash
impl Hash for DefPathHash
sourceimpl<__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)
sourceimpl Ord for DefPathHash
impl Ord for DefPathHash
sourcefn cmp(&self, other: &DefPathHash) -> Ordering
fn cmp(&self, other: &DefPathHash) -> Ordering
1.21.0 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
sourceimpl PartialEq<DefPathHash> for DefPathHash
impl PartialEq<DefPathHash> for DefPathHash
sourcefn eq(&self, other: &DefPathHash) -> bool
fn eq(&self, other: &DefPathHash) -> bool
sourceimpl PartialOrd<DefPathHash> for DefPathHash
impl PartialOrd<DefPathHash> for DefPathHash
sourcefn partial_cmp(&self, other: &DefPathHash) -> Option<Ordering>
fn partial_cmp(&self, other: &DefPathHash) -> Option<Ordering>
1.0.0 · sourcefn 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
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn 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