local_def_path_hash_to_def_id can fail

local_def_path_hash_to_def_id is used by Debug impl for DepNode and it
looks for DefPathHash inside the current compilation. During incremental
compilation we are going through nodes that belong to a previous
compilation and might not be present and a simple attempt to print such
node with tracing::debug (try_mark_parent_green does it for example)
results in a otherwise avoidable panic

Panic was added in https://github.com/rust-lang/rust/pull/82183,
specifically in 2b60338ee9, with a comment "We only use this mapping for
cases where we know that it must succeed.", but I'm not sure if this
property holds when we traverse nodes from the old compilation in order
to figure out if they are valid or not

compiler/rustc_hir/src/definitions.rs

@@ -377,22 +377,17 @@ pub fn create_def(&mut self, parent: LocalDefId, data: DefPathData) -> LocalDefI
     }
 
     #[inline(always)]
-    pub fn local_def_path_hash_to_def_id(
+    /// Returns `None` if the `DefPathHash` does not correspond to a `LocalDefId`
-        &self,
+    /// in the current compilation session. This can legitimately happen if the
-        hash: DefPathHash,
+    /// `DefPathHash` is from a `DefId` in an upstream crate or, during incr. comp.,
-        err_msg: &dyn std::fmt::Debug,
+    /// if the `DefPathHash` is from a previous compilation session and
-    ) -> LocalDefId {
+    /// the def-path does not exist anymore.
+    pub fn local_def_path_hash_to_def_id(&self, hash: DefPathHash) -> Option<LocalDefId> {
         debug_assert!(hash.stable_crate_id() == self.table.stable_crate_id);
-        #[cold]
-        #[inline(never)]
-        fn err(err_msg: &dyn std::fmt::Debug) -> ! {
-            panic!("{err_msg:?}")
-        }
         self.table
             .def_path_hash_to_index
             .get(&hash.local_hash())
             .map(|local_def_index| LocalDefId { local_def_index })
-            .unwrap_or_else(|| err(err_msg))
     }
 
     pub fn def_path_hash_to_def_index_map(&self) -> &DefPathHashMap {

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -194,10 +194,7 @@ impl DepNodeExt for DepNode {
     /// has been removed.
     fn extract_def_id(&self, tcx: TyCtxt<'_>) -> Option<DefId> {
         if tcx.fingerprint_style(self.kind) == FingerprintStyle::DefPathHash {
-            Some(tcx.def_path_hash_to_def_id(
+            tcx.def_path_hash_to_def_id(DefPathHash(self.hash.into()))
-                DefPathHash(self.hash.into()),
-                &("Failed to extract DefId", self.kind, self.hash),
-            ))
         } else {
             None
         }
@@ -390,12 +387,7 @@ fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
         if tcx.fingerprint_style(dep_node.kind) == FingerprintStyle::HirId {
             let (local_hash, local_id) = Fingerprint::from(dep_node.hash).split();
             let def_path_hash = DefPathHash::new(tcx.stable_crate_id(LOCAL_CRATE), local_hash);
-            let def_id = tcx
+            let def_id = tcx.def_path_hash_to_def_id(def_path_hash)?.expect_local();
-                .def_path_hash_to_def_id(
-                    def_path_hash,
-                    &("Failed to extract HirId", dep_node.kind, dep_node.hash),
-                )
-                .expect_local();
             let local_id = local_id
                 .as_u64()
                 .try_into()

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -733,10 +733,10 @@ fn decode_def_id(&mut self) -> DefId {
         // If we get to this point, then all of the query inputs were green,
         // which means that the definition with this hash is guaranteed to
         // still exist in the current compilation session.
-        self.tcx.def_path_hash_to_def_id(
+        match self.tcx.def_path_hash_to_def_id(def_path_hash) {
-            def_path_hash,
+            Some(r) => r,
-            &("Failed to convert DefPathHash", def_path_hash),
+            None => panic!("Failed to convert DefPathHash {def_path_hash:?}"),
-        )
+        }
     }
 
     fn decode_attr_id(&mut self) -> rustc_span::AttrId {

compiler/rustc_middle/src/ty/context.rs

@@ -1677,11 +1677,7 @@ pub fn stable_crate_id_to_crate_num(self, stable_crate_id: StableCrateId) -> Cra
     /// Converts a `DefPathHash` to its corresponding `DefId` in the current compilation
     /// session, if it still exists. This is used during incremental compilation to
     /// turn a deserialized `DefPathHash` into its current `DefId`.
-    pub fn def_path_hash_to_def_id(
+    pub fn def_path_hash_to_def_id(self, hash: DefPathHash) -> Option<DefId> {
-        self,
-        hash: DefPathHash,
-        err_msg: &dyn std::fmt::Debug,
-    ) -> DefId {
         debug!("def_path_hash_to_def_id({:?})", hash);
 
         let stable_crate_id = hash.stable_crate_id();
@@ -1689,13 +1685,9 @@ pub fn def_path_hash_to_def_id(
         // If this is a DefPathHash from the local crate, we can look up the
         // DefId in the tcx's `Definitions`.
         if stable_crate_id == self.stable_crate_id(LOCAL_CRATE) {
-            self.untracked
+            Some(self.untracked.definitions.read().local_def_path_hash_to_def_id(hash)?.to_def_id())
-                .definitions
-                .read()
-                .local_def_path_hash_to_def_id(hash, err_msg)
-                .to_def_id()
         } else {
-            self.def_path_hash_to_def_id_extern(hash, stable_crate_id)
+            Some(self.def_path_hash_to_def_id_extern(hash, stable_crate_id))
         }
     }