Rollup merge of #134806 - notriddle:notriddle/parent-path-is-better, …

…r=GuillaumeGomez

rustdoc: use shorter paths as preferred canonical paths

This is a solution to [the `std::sync::poison` linking problem](#134692 (comment)), and, in general, makes intra-doc links shorter and clearer.

> Done. This helped with the search, but not with the things like `MutexGuard`'s doc's reference to `Mutex::lock` being converted to the absolute (unstable) `std::sync::poison::Mutex` path.

cc `@tgross35`

r? `@GuillaumeGomez`

src/librustdoc/formats/cache.rs

@@ -305,6 +305,7 @@ impl DocFolder for CacheBuilder<'_, '_> {
             | clean::MacroItem(..)
             | clean::ProcMacroItem(..)
             | clean::VariantItem(..) => {
+                use rustc_data_structures::fx::IndexEntry as Entry;
                 if !self.cache.stripped_mod {
                     // Re-exported items mean that the same id can show up twice
                     // in the rustdoc ast that we're looking at. We know,
@@ -313,15 +314,15 @@ impl DocFolder for CacheBuilder<'_, '_> {
                     // paths map if there was already an entry present and we're
                     // not a public item.
                     let item_def_id = item.item_id.expect_def_id();
-                    if !self.cache.paths.contains_key(&item_def_id)
-                        || self
-                            .cache
-                            .effective_visibilities
-                            .is_directly_public(self.tcx, item_def_id)
-                    {
-                        self.cache
-                            .paths
-                            .insert(item_def_id, (self.cache.stack.clone(), item.type_()));
+                    match self.cache.paths.entry(item_def_id) {
+                        Entry::Vacant(entry) => {
+                            entry.insert((self.cache.stack.clone(), item.type_()));
+                        }
+                        Entry::Occupied(mut entry) => {
+                            if entry.get().0.len() > self.cache.stack.len() {
+                                entry.insert((self.cache.stack.clone(), item.type_()));
+                            }
+                        }
                     }
                 }
             }

tests/rustdoc-js-std/path-maxeditdistance.js

@@ -17,10 +17,10 @@ const EXPECTED = [
             { 'path': 'std::vec::IntoIter', 'name': 'into_iter' },
             { 'path': 'std::vec::ExtractIf', 'name': 'into_iter' },
             { 'path': 'std::vec::Splice', 'name': 'into_iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'iter_mut' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'from_iter' },
-            { 'path': 'std::collections::vec_deque::VecDeque', 'name': 'into_iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'iter_mut' },
+            { 'path': 'std::collections::VecDeque', 'name': 'from_iter' },
+            { 'path': 'std::collections::VecDeque', 'name': 'into_iter' },
         ],
     },
     {

tests/rustdoc-js-std/path-ordering.js

@@ -3,17 +3,17 @@ const EXPECTED = [
         query: 'hashset::insert',
         others: [
             // ensure hashset::insert comes first
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'get_or_insert_with' },
+            { 'path': 'std::collections::HashSet', 'name': 'insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'get_or_insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'get_or_insert_with' },
         ],
     },
     {
         query: 'hash::insert',
         others: [
             // ensure hashset/hashmap::insert come first
-            { 'path': 'std::collections::hash_map::HashMap', 'name': 'insert' },
-            { 'path': 'std::collections::hash_set::HashSet', 'name': 'insert' },
+            { 'path': 'std::collections::HashMap', 'name': 'insert' },
+            { 'path': 'std::collections::HashSet', 'name': 'insert' },
         ],
     },
 ];

tests/rustdoc-js-std/simd-type-signatures.js

@@ -11,59 +11,59 @@ const EXPECTED = [
         'query': 'simd<i16>, simd<i16> -> simd<i16>',
         'others': [
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_max',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_max'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_max'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_min',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_min'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_min'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_add',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_add'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_add'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_sub',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_sub'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci16,+N%3E/method.saturating_sub'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_clamp',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_clamp'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci16,+N%3E/method.simd_clamp'
             },
         ],
     },
     {
         'query': 'simd<i8>, simd<i8> -> simd<i8>',
         'others': [
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_max',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_max'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_max'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_min',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_min'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_min'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_add',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_add'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_add'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'saturating_sub',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_sub'
+                'href': '../std/simd/struct.Simd.html#impl-SimdInt-for-Simd%3Ci8,+N%3E/method.saturating_sub'
             },
             {
-                'path': 'std::simd::prelude::Simd',
+                'path': 'std::simd::Simd',
                 'name': 'simd_clamp',
-                'href': '../std/simd/prelude/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_clamp'
+                'href': '../std/simd/struct.Simd.html#impl-SimdOrd-for-Simd%3Ci8,+N%3E/method.simd_clamp'
             },
         ],
     },

tests/rustdoc/inline_local/parent-path-is-better.rs

@@ -0,0 +1,40 @@
+//! Test case for [134702]
+//!
+//! [134702]: https://github.com/rust-lang/rust/issues/134702
+#![crate_name = "foo"]
+
+pub mod inside1 {
+    pub use self::inner::Inside1;
+    mod inner {
+        pub struct Inside1;
+        impl Inside1 {
+            pub fn stuff(self) {}
+        }
+    }
+}
+
+pub mod inside2 {
+    pub use self::inner::Inside2;
+    mod inner {
+        pub struct Inside2;
+        impl Inside2 {
+            pub fn stuff(self) {}
+        }
+    }
+}
+
+pub mod nested {
+    //! [Inside1] [Inside2]
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside1.html"]' 'Inside1'
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside2.html"]' 'Inside2'
+    //! [Inside1::stuff] [Inside2::stuff]
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside1.html#method.stuff"]' 'Inside1::stuff'
+    //@ has foo/nested/index.html '//a[@href="../struct.Inside2.html#method.stuff"]' 'Inside2::stuff'
+    use crate::inside1::Inside1;
+    use crate::inside2::Inside2;
+}
+
+#[doc(inline)]
+pub use inside1::Inside1;
+#[doc(inline)]
+pub use inside2::Inside2;

tests/rustdoc/intra-doc/pub-use.rs

@@ -7,7 +7,7 @@ extern crate inner;
 /// [mod@std::env] [g]
 //@ has outer/index.html
 //@ has - '//a[@href="{{channel}}/std/env/index.html"]' "std::env"
-//@ has - '//a[@href="fn.f.html"]' "g"
+//@ has - '//a[@href="fn.g.html"]' "g"
 pub use f as g;
 
 // Make sure the documentation is actually correct by documenting an inlined re-export