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
Immutably borrows from an owned value. Read more
sourceimpl Clone for DefPathHash
impl Clone for DefPathHash
sourcefn clone(&self) -> DefPathHash
fn clone(&self) -> DefPathHash
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl Debug for DefPathHash
impl Debug for DefPathHash
sourceimpl<__E: Encoder> Encodable<__E> for DefPathHash
impl<__E: Encoder> Encodable<__E> for DefPathHash
sourceimpl Hash for DefPathHash
impl Hash for DefPathHash
sourceimpl<__CTX> HashStable<__CTX> for DefPathHash where
__CTX: HashStableContext,
impl<__CTX> HashStable<__CTX> for DefPathHash where
__CTX: HashStableContext,
fn hash_stable(&self, __hcx: &mut __CTX, __hasher: &mut StableHasher)
sourceimpl Ord for DefPathHash
impl Ord for DefPathHash
sourceimpl PartialEq<DefPathHash> for DefPathHash
impl PartialEq<DefPathHash> for DefPathHash
sourcefn eq(&self, other: &DefPathHash) -> bool
fn eq(&self, other: &DefPathHash) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
sourcefn ne(&self, other: &DefPathHash) -> bool
fn ne(&self, other: &DefPathHash) -> bool
This method tests for !=
.
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>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
impl 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 T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
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