Merge branch 'rust-lang:master' into feat/macros/hash_map

stifskere · web-flow · commit 3d020f6e69a4 · 2025-07-17T14:52:35.000+02:00
diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs
@@ -140,7 +140,9 @@ impl DefKey {
     pub(crate) fn compute_stable_hash(&self, parent: DefPathHash) -> DefPathHash {
         let mut hasher = StableHasher::new();
 
-        parent.hash(&mut hasher);
+        // The new path is in the same crate as `parent`, and will contain the stable_crate_id.
+        // Therefore, we only need to include information of the parent's local hash.
+        parent.local_hash().hash(&mut hasher);
 
         let DisambiguatedDefPathData { ref data, disambiguator } = self.disambiguated_data;
 
@@ -355,8 +357,16 @@ impl Definitions {
             },
         };
 
-        let parent_hash = DefPathHash::new(stable_crate_id, Hash64::ZERO);
-        let def_path_hash = key.compute_stable_hash(parent_hash);
+        // We want *both* halves of a DefPathHash to depend on the crate-id of the defining crate.
+        // The crate-id can be more easily changed than the DefPath of an item, so, in the case of
+        // a crate-local DefPathHash collision, the user can simply "roll the dice again" for all
+        // DefPathHashes in the crate by changing the crate disambiguator (e.g. via bumping the
+        // crate's version number).
+        //
+        // Children paths will only hash the local portion, and still inherit the change to the
+        // root hash.
+        let def_path_hash =
+            DefPathHash::new(stable_crate_id, Hash64::new(stable_crate_id.as_u64()));
 
         // Create the root definition.
         let mut table = DefPathTable::new(stable_crate_id);
diff --git a/compiler/rustc_hir/src/tests.rs b/compiler/rustc_hir/src/tests.rs
@@ -28,7 +28,8 @@ fn def_path_hash_depends_on_crate_id() {
         assert_ne!(h0.local_hash(), h1.local_hash());
 
         fn mk_test_hash(stable_crate_id: StableCrateId) -> DefPathHash {
-            let parent_hash = DefPathHash::new(stable_crate_id, Hash64::ZERO);
+            let parent_hash =
+                DefPathHash::new(stable_crate_id, Hash64::new(stable_crate_id.as_u64()));
 
             let key = DefKey {
                 parent: None,
diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs
@@ -110,6 +110,7 @@ impl DefPathHash {
 
     /// Builds a new [DefPathHash] with the given [StableCrateId] and
     /// `local_hash`, where `local_hash` must be unique within its crate.
+    #[inline]
     pub fn new(stable_crate_id: StableCrateId, local_hash: Hash64) -> DefPathHash {
         DefPathHash(Fingerprint::new(stable_crate_id.0, local_hash))
     }
@@ -404,21 +405,21 @@ rustc_data_structures::define_id_collections!(
 impl<CTX: HashStableContext> HashStable<CTX> for DefId {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        hcx.def_path_hash(*self).hash_stable(hcx, hasher);
     }
 }
 
 impl<CTX: HashStableContext> HashStable<CTX> for LocalDefId {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        hcx.def_path_hash(self.to_def_id()).local_hash().hash_stable(hcx, hasher);
     }
 }
 
 impl<CTX: HashStableContext> HashStable<CTX> for CrateNum {
     #[inline]
     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
-        self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);
+        self.as_def_id().to_stable_hash_key(hcx).stable_crate_id().hash_stable(hcx, hasher);
     }
 }
 
@@ -464,30 +465,36 @@ macro_rules! typed_def_id {
         pub struct $Name(DefId);
 
         impl $Name {
+            #[inline]
             pub const fn new_unchecked(def_id: DefId) -> Self {
                 Self(def_id)
             }
 
+            #[inline]
             pub fn to_def_id(self) -> DefId {
                 self.into()
             }
 
+            #[inline]
             pub fn is_local(self) -> bool {
                 self.0.is_local()
             }
 
+            #[inline]
             pub fn as_local(self) -> Option<$LocalName> {
                 self.0.as_local().map($LocalName::new_unchecked)
             }
         }
 
         impl From<$LocalName> for $Name {
+            #[inline]
             fn from(local: $LocalName) -> Self {
                 Self(local.0.to_def_id())
             }
         }
 
         impl From<$Name> for DefId {
+            #[inline]
             fn from(typed: $Name) -> Self {
                 typed.0
             }
@@ -500,26 +507,31 @@ macro_rules! typed_def_id {
         impl !PartialOrd for $LocalName {}
 
         impl $LocalName {
+            #[inline]
             pub const fn new_unchecked(def_id: LocalDefId) -> Self {
                 Self(def_id)
             }
 
+            #[inline]
             pub fn to_def_id(self) -> DefId {
                 self.0.into()
             }
 
+            #[inline]
             pub fn to_local_def_id(self) -> LocalDefId {
                 self.0
             }
         }
 
         impl From<$LocalName> for LocalDefId {
+            #[inline]
             fn from(typed: $LocalName) -> Self {
                 typed.0
             }
         }
 
         impl From<$LocalName> for DefId {
+            #[inline]
             fn from(typed: $LocalName) -> Self {
                 typed.0.into()
             }
diff --git a/tests/mir-opt/inline/cycle.rs b/tests/mir-opt/inline/cycle.rs
@@ -13,7 +13,7 @@ fn f(g: impl Fn()) {
 #[inline(always)]
 fn g() {
     // CHECK-LABEL: fn g(
-    // CHECK-NOT: (inlined f::<fn() {main}>)
+    // CHECK-NOT: inlined
     f(main);
 }
 
diff --git a/tests/ui/symbol-names/basic.legacy.stderr b/tests/ui/symbol-names/basic.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN5basic4main17hc88b9d80a69d119aE)
+error: symbol-name(_ZN5basic4main17h1dddcfd03744167fE)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(basic::main::hc88b9d80a69d119a)
+error: demangling(basic::main::h1dddcfd03744167f)
   --> $DIR/basic.rs:8:1
    |
 LL | #[rustc_symbol_name]
diff --git a/tests/ui/symbol-names/issue-60925.legacy.stderr b/tests/ui/symbol-names/issue-60925.legacy.stderr
@@ -1,10 +1,10 @@
-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17hbddb77d6f71afb32E)
+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h4b3099ec5dc5d306E)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
    |         ^^^^^^^^^^^^^^^^^^^^
 
-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::hbddb77d6f71afb32)
+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h4b3099ec5dc5d306)
   --> $DIR/issue-60925.rs:21:9
    |
 LL |         #[rustc_symbol_name]
diff --git a/tests/ui/thir-print/thir-tree-match.stdout b/tests/ui/thir-print/thir-tree-match.stdout
@@ -94,7 +94,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 0
                                                                                         subpatterns: [
@@ -108,7 +108,7 @@ body:
                                                                                                                 did: DefId(0:3 ~ thir_tree_match[fcf8]::Bar)
                                                                                                                 variants: [VariantDef { def_id: DefId(0:4 ~ thir_tree_match[fcf8]::Bar::First), ctor: Some((Const, DefId(0:5 ~ thir_tree_match[fcf8]::Bar::First::{constructor#0}))), name: "First", discr: Relative(0), fields: [], tainted: None, flags:  }, VariantDef { def_id: DefId(0:6 ~ thir_tree_match[fcf8]::Bar::Second), ctor: Some((Const, DefId(0:7 ~ thir_tree_match[fcf8]::Bar::Second::{constructor#0}))), name: "Second", discr: Relative(1), fields: [], tainted: None, flags:  }, VariantDef { def_id: DefId(0:8 ~ thir_tree_match[fcf8]::Bar::Third), ctor: Some((Const, DefId(0:9 ~ thir_tree_match[fcf8]::Bar::Third::{constructor#0}))), name: "Third", discr: Relative(2), fields: [], tainted: None, flags:  }]
                                                                                                                 flags: IS_ENUM
-                                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 10333377570083945360 }
+                                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 7908585036048874241 }
                                                                                                         args: []
                                                                                                         variant_index: 0
                                                                                                         subpatterns: []
@@ -156,7 +156,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 0
                                                                                         subpatterns: [
@@ -208,7 +208,7 @@ body:
                                                                                                 did: DefId(0:10 ~ thir_tree_match[fcf8]::Foo)
                                                                                                 variants: [VariantDef { def_id: DefId(0:11 ~ thir_tree_match[fcf8]::Foo::FooOne), ctor: Some((Fn, DefId(0:12 ~ thir_tree_match[fcf8]::Foo::FooOne::{constructor#0}))), name: "FooOne", discr: Relative(0), fields: [FieldDef { did: DefId(0:13 ~ thir_tree_match[fcf8]::Foo::FooOne::0), name: "0", vis: Restricted(DefId(0:0 ~ thir_tree_match[fcf8])), safety: Safe, value: None }], tainted: None, flags:  }, VariantDef { def_id: DefId(0:14 ~ thir_tree_match[fcf8]::Foo::FooTwo), ctor: Some((Const, DefId(0:15 ~ thir_tree_match[fcf8]::Foo::FooTwo::{constructor#0}))), name: "FooTwo", discr: Relative(1), fields: [], tainted: None, flags:  }]
                                                                                                 flags: IS_ENUM
-                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 3477539199540094892 }
+                                                                                                repr: ReprOptions { int: None, align: None, pack: None, flags: , field_shuffle_seed: 13397682652773712997 }
                                                                                         args: []
                                                                                         variant_index: 1
                                                                                         subpatterns: []

Original file line number	Diff line number	Diff line change
`@@ -110,6 +110,7 @@ impl DefPathHash {`
`110`	`110`
`111`	`111`	`/// Builds a new [DefPathHash] with the given [StableCrateId] and`
`112`	`112`	/// `local_hash`, where `local_hash` must be unique within its crate.
	`113`	`+ #[inline]`
`113`	`114`	`pub fn new(stable_crate_id: StableCrateId, local_hash: Hash64) -> DefPathHash {`
`114`	`115`	`DefPathHash(Fingerprint::new(stable_crate_id.0, local_hash))`
`115`	`116`	`}`
`@@ -404,21 +405,21 @@ rustc_data_structures::define_id_collections!(`
`404`	`405`	`impl<CTX: HashStableContext> HashStable<CTX> for DefId {`
`405`	`406`	`#[inline]`
`406`	`407`	`fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {`
`407`		`- self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);`
	`408`	`+ hcx.def_path_hash(*self).hash_stable(hcx, hasher);`
`408`	`409`	`}`
`409`	`410`	`}`
`410`	`411`
`411`	`412`	`impl<CTX: HashStableContext> HashStable<CTX> for LocalDefId {`
`412`	`413`	`#[inline]`
`413`	`414`	`fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {`
`414`		`- self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);`
	`415`	`+ hcx.def_path_hash(self.to_def_id()).local_hash().hash_stable(hcx, hasher);`
`415`	`416`	`}`
`416`	`417`	`}`
`417`	`418`
`418`	`419`	`impl<CTX: HashStableContext> HashStable<CTX> for CrateNum {`
`419`	`420`	`#[inline]`
`420`	`421`	`fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {`
`421`		`- self.to_stable_hash_key(hcx).hash_stable(hcx, hasher);`
	`422`	`+ self.as_def_id().to_stable_hash_key(hcx).stable_crate_id().hash_stable(hcx, hasher);`
`422`	`423`	`}`
`423`	`424`	`}`
`424`	`425`
`@@ -464,30 +465,36 @@ macro_rules! typed_def_id {`
`464`	`465`	`pub struct $Name(DefId);`
`465`	`466`
`466`	`467`	`impl $Name {`
	`468`	`+ #[inline]`
`467`	`469`	`pub const fn new_unchecked(def_id: DefId) -> Self {`
`468`	`470`	`Self(def_id)`
`469`	`471`	`}`
`470`	`472`
	`473`	`+ #[inline]`
`471`	`474`	`pub fn to_def_id(self) -> DefId {`
`472`	`475`	`self.into()`
`473`	`476`	`}`
`474`	`477`
	`478`	`+ #[inline]`
`475`	`479`	`pub fn is_local(self) -> bool {`
`476`	`480`	`self.0.is_local()`
`477`	`481`	`}`
`478`	`482`
	`483`	`+ #[inline]`
`479`	`484`	`pub fn as_local(self) -> Option<$LocalName> {`
`480`	`485`	`self.0.as_local().map($LocalName::new_unchecked)`
`481`	`486`	`}`
`482`	`487`	`}`
`483`	`488`
`484`	`489`	`impl From<$LocalName> for $Name {`
	`490`	`+ #[inline]`
`485`	`491`	`fn from(local: $LocalName) -> Self {`
`486`	`492`	`Self(local.0.to_def_id())`
`487`	`493`	`}`
`488`	`494`	`}`
`489`	`495`
`490`	`496`	`impl From<$Name> for DefId {`
	`497`	`+ #[inline]`
`491`	`498`	`fn from(typed: $Name) -> Self {`
`492`	`499`	`typed.0`
`493`	`500`	`}`
`@@ -500,26 +507,31 @@ macro_rules! typed_def_id {`
`500`	`507`	`impl !PartialOrd for $LocalName {}`
`501`	`508`
`502`	`509`	`impl $LocalName {`
	`510`	`+ #[inline]`
`503`	`511`	`pub const fn new_unchecked(def_id: LocalDefId) -> Self {`
`504`	`512`	`Self(def_id)`
`505`	`513`	`}`
`506`	`514`
	`515`	`+ #[inline]`
`507`	`516`	`pub fn to_def_id(self) -> DefId {`
`508`	`517`	`self.0.into()`
`509`	`518`	`}`
`510`	`519`
	`520`	`+ #[inline]`
`511`	`521`	`pub fn to_local_def_id(self) -> LocalDefId {`
`512`	`522`	`self.0`
`513`	`523`	`}`
`514`	`524`	`}`
`515`	`525`
`516`	`526`	`impl From<$LocalName> for LocalDefId {`
	`527`	`+ #[inline]`
`517`	`528`	`fn from(typed: $LocalName) -> Self {`
`518`	`529`	`typed.0`
`519`	`530`	`}`
`520`	`531`	`}`
`521`	`532`
`522`	`533`	`impl From<$LocalName> for DefId {`
	`534`	`+ #[inline]`
`523`	`535`	`fn from(typed: $LocalName) -> Self {`
`524`	`536`	`typed.0.into()`
`525`	`537`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ fn f(g: impl Fn()) {`
`13`	`13`	`#[inline(always)]`
`14`	`14`	`fn g() {`
`15`	`15`	`// CHECK-LABEL: fn g(`
`16`		`- // CHECK-NOT: (inlined f::<fn() {main}>)`
	`16`	`+ // CHECK-NOT: inlined`
`17`	`17`	`f(main);`
`18`	`18`	`}`
`19`	`19`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,10 @@`
`1`		`-error: symbol-name(_ZN5basic4main17hc88b9d80a69d119aE)`
	`1`	`+error: symbol-name(_ZN5basic4main17h1dddcfd03744167fE)`
`2`	`2`	`--> $DIR/basic.rs:8:1`
`3`	`3`	`\|`
`4`	`4`	`LL \| #[rustc_symbol_name]`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^`
`6`	`6`
`7`		`-error: demangling(basic::main::hc88b9d80a69d119a)`
	`7`	`+error: demangling(basic::main::h1dddcfd03744167f)`
`8`	`8`	`--> $DIR/basic.rs:8:1`
`9`	`9`	`\|`
`10`	`10`	`LL \| #[rustc_symbol_name]`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,10 @@`
`1`		`-error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17hbddb77d6f71afb32E)`
	`1`	`+error: symbol-name(_ZN11issue_609253foo37Foo$LT$issue_60925..llv$u6d$..Foo$GT$3foo17h4b3099ec5dc5d306E)`
`2`	`2`	`--> $DIR/issue-60925.rs:21:9`
`3`	`3`	`\|`
`4`	`4`	`LL \| #[rustc_symbol_name]`
`5`	`5`	`\| ^^^^^^^^^^^^^^^^^^^^`
`6`	`6`
`7`		`-error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::hbddb77d6f71afb32)`
	`7`	`+error: demangling(issue_60925::foo::Foo<issue_60925::llvm::Foo>::foo::h4b3099ec5dc5d306)`
`8`	`8`	`--> $DIR/issue-60925.rs:21:9`
`9`	`9`	`\|`
`10`	`10`	`LL \| #[rustc_symbol_name]`