fix: Check the fallback map before queueing child in visible_parent_map BFS

Author: zalanlevai

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -472,7 +472,7 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
             // the former.
             // This is a rudimentary check that does not catch all cases,
             // just the easiest.
-            let mut fallback_map: Vec<(DefId, DefId)> = Default::default();
+            let mut fallback_map: DefIdMap<DefId> = Default::default();
 
             // Issue 46112: We want the map to prefer the shortest
             // paths when reporting the path to an item. Therefore we
@@ -533,14 +533,24 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
                             }
                         }
                         Entry::Vacant(entry) => {
+                            if !fallback {
+                                entry.insert(parent);
+                            }
+
+                            // Make sure that we have not already explored this child
+                            // through a previous fallback entry further up the BFS,
+                            // in which case we do not want to put it back into the BFS queue,
+                            // nor record a new fallback parent.
+                            if fallback_map.contains_key(&def_id) {
+                                return;
+                            }
+
                             if fallback {
                                 // We do all of the same steps to fallback entries as to
                                 // preferred entries, except for recording them in a separate map.
                                 // It is important to not return early in the fallback cases to
                                 // ensure that we extend the BFS to the children of fallback items.
-                                fallback_map.push((def_id, parent));
-                            } else {
-                                entry.insert(parent);
+                                fallback_map.insert(def_id, parent);
                             }
 
                             if child.res.module_like_def_id().is_some() {
@@ -560,10 +570,11 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
             // Fill in any missing entries with the less preferable path.
             // If this path re-exports the child as `_`, we still use this
             // path in a diagnostic that suggests importing `::*`.
-
-            for (child, parent) in fallback_map {
-                visible_parent_map.entry(child).or_insert(parent);
-            }
+            tcx.with_stable_hashing_context(|mut hcx| {
+                for (child, parent) in fallback_map.into_sorted(&mut hcx, true) {
+                    visible_parent_map.entry(child).or_insert(parent);
+                }
+            });
 
             visible_parent_map
         },