Implement namespacing for doc comments IDs

Author: GuillaumeGomez

src/librustdoc/externalfiles.rs

@@ -1,4 +1,4 @@
-use crate::html::markdown::{ErrorCodes, HeadingOffset, IdMap, Markdown, Playground};
+use crate::html::markdown::{ErrorCodes, HeadingOffset, IdMap, IdPrefix, Markdown, Playground};
 use crate::rustc_span::edition::Edition;
 use std::fs;
 use std::path::Path;
@@ -47,6 +47,7 @@ impl ExternalHtml {
                 edition,
                 playground,
                 heading_offset: HeadingOffset::H2,
+                id_prefix: IdPrefix::without_parent(),
             }
             .into_string()
         );
@@ -63,6 +64,7 @@ impl ExternalHtml {
                 edition,
                 playground,
                 heading_offset: HeadingOffset::H2,
+                id_prefix: IdPrefix::without_parent(),
             }
             .into_string()
         );

src/librustdoc/html/markdown.rs

@@ -8,7 +8,7 @@
 //! extern crate rustc_span;
 //!
 //! use rustc_span::edition::Edition;
-//! use rustdoc::html::markdown::{HeadingOffset, IdMap, Markdown, ErrorCodes};
+//! use rustdoc::html::markdown::{HeadingOffset, IdMap, IdPrefix, Markdown, ErrorCodes};
 //!
 //! let s = "My *markdown* _text_";
 //! let mut id_map = IdMap::new();
@@ -20,6 +20,7 @@
 //!     edition: Edition::Edition2015,
 //!     playground: &None,
 //!     heading_offset: HeadingOffset::H2,
+//!     id_prefix: IdPrefix::none(),
 //! };
 //! let html = md.into_string();
 //! // ... something using html
@@ -40,7 +41,7 @@ use std::fmt::Write;
 use std::ops::{ControlFlow, Range};
 use std::str;
 
-use crate::clean::RenderedLink;
+use crate::clean::{self, RenderedLink};
 use crate::doctest;
 use crate::html::escape::Escape;
 use crate::html::format::Buffer;
@@ -101,6 +102,7 @@ pub struct Markdown<'a> {
     /// Offset at which we render headings.
     /// E.g. if `heading_offset: HeadingOffset::H2`, then `# something` renders an `<h2>`.
     pub heading_offset: HeadingOffset,
+    pub id_prefix: IdPrefix<'a>,
 }
 /// A tuple struct like `Markdown` that renders the markdown with a table of contents.
 crate struct MarkdownWithToc<'a>(
@@ -109,6 +111,7 @@ crate struct MarkdownWithToc<'a>(
     crate ErrorCodes,
     crate Edition,
     crate &'a Option<Playground>,
+    crate IdPrefix<'a>,
 );
 /// A tuple struct like `Markdown` that renders the markdown escaping HTML tags.
 crate struct MarkdownHtml<'a>(
@@ -117,6 +120,7 @@ crate struct MarkdownHtml<'a>(
     crate ErrorCodes,
     crate Edition,
     crate &'a Option<Playground>,
+    crate IdPrefix<'a>,
 );
 /// A tuple struct like `Markdown` that renders only the first paragraph.
 crate struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
@@ -508,27 +512,36 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for TableWrapper<'a, I> {
 type SpannedEvent<'a> = (Event<'a>, Range<usize>);
 
 /// Make headings links with anchor IDs and build up TOC.
-struct HeadingLinks<'a, 'b, 'ids, I> {
+struct HeadingLinks<'a, 'b, 'ids, 'c, I> {
     inner: I,
     toc: Option<&'b mut TocBuilder>,
     buf: VecDeque<SpannedEvent<'a>>,
     id_map: &'ids mut IdMap,
     heading_offset: HeadingOffset,
+    id_prefix: IdPrefix<'c>,
 }
 
-impl<'a, 'b, 'ids, I> HeadingLinks<'a, 'b, 'ids, I> {
+impl<'a, 'b, 'ids, 'c, I> HeadingLinks<'a, 'b, 'ids, 'c, I> {
     fn new(
         iter: I,
         toc: Option<&'b mut TocBuilder>,
         ids: &'ids mut IdMap,
         heading_offset: HeadingOffset,
+        id_prefix: IdPrefix<'c>,
     ) -> Self {
-        HeadingLinks { inner: iter, toc, buf: VecDeque::new(), id_map: ids, heading_offset }
+        HeadingLinks {
+            inner: iter,
+            toc,
+            buf: VecDeque::new(),
+            id_map: ids,
+            heading_offset,
+            id_prefix,
+        }
     }
 }
 
-impl<'a, 'b, 'ids, I: Iterator<Item = SpannedEvent<'a>>> Iterator
-    for HeadingLinks<'a, 'b, 'ids, I>
+impl<'a, 'b, 'ids, 'c, I: Iterator<Item = SpannedEvent<'a>>> Iterator
+    for HeadingLinks<'a, 'b, 'ids, 'c, I>
 {
     type Item = SpannedEvent<'a>;
 
@@ -551,7 +564,7 @@ impl<'a, 'b, 'ids, I: Iterator<Item = SpannedEvent<'a>>> Iterator
                     _ => self.buf.push_back(event),
                 }
             }
-            let id = self.id_map.derive(id);
+            let id = self.id_map.derive(id, self.id_prefix);
 
             if let Some(ref mut builder) = self.toc {
                 let mut html_header = String::new();
@@ -1044,6 +1057,7 @@ impl Markdown<'_> {
             edition,
             playground,
             heading_offset,
+            id_prefix,
         } = self;
 
         // This is actually common enough to special-case
@@ -1062,7 +1076,7 @@ impl Markdown<'_> {
 
         let mut s = String::with_capacity(md.len() * 3 / 2);
 
-        let p = HeadingLinks::new(p, None, &mut ids, heading_offset);
+        let p = HeadingLinks::new(p, None, &mut ids, heading_offset, id_prefix);
         let p = Footnotes::new(p);
         let p = LinkReplacer::new(p.map(|(ev, _)| ev), links);
         let p = TableWrapper::new(p);
@@ -1075,7 +1089,7 @@ impl Markdown<'_> {
 
 impl MarkdownWithToc<'_> {
     crate fn into_string(self) -> String {
-        let MarkdownWithToc(md, mut ids, codes, edition, playground) = self;
+        let MarkdownWithToc(md, mut ids, codes, edition, playground, id_prefix) = self;
 
         let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
 
@@ -1084,7 +1098,7 @@ impl MarkdownWithToc<'_> {
         let mut toc = TocBuilder::new();
 
         {
-            let p = HeadingLinks::new(p, Some(&mut toc), &mut ids, HeadingOffset::H1);
+            let p = HeadingLinks::new(p, Some(&mut toc), &mut ids, HeadingOffset::H1, id_prefix);
             let p = Footnotes::new(p);
             let p = TableWrapper::new(p.map(|(ev, _)| ev));
             let p = CodeBlocks::new(p, codes, edition, playground);
@@ -1097,7 +1111,7 @@ impl MarkdownWithToc<'_> {
 
 impl MarkdownHtml<'_> {
     crate fn into_string(self) -> String {
-        let MarkdownHtml(md, mut ids, codes, edition, playground) = self;
+        let MarkdownHtml(md, mut ids, codes, edition, playground, id_prefix) = self;
 
         // This is actually common enough to special-case
         if md.is_empty() {
@@ -1113,7 +1127,7 @@ impl MarkdownHtml<'_> {
 
         let mut s = String::with_capacity(md.len() * 3 / 2);
 
-        let p = HeadingLinks::new(p, None, &mut ids, HeadingOffset::H1);
+        let p = HeadingLinks::new(p, None, &mut ids, HeadingOffset::H1, id_prefix);
         let p = Footnotes::new(p);
         let p = TableWrapper::new(p.map(|(ev, _)| ev));
         let p = CodeBlocks::new(p, codes, edition, playground);
@@ -1325,7 +1339,8 @@ crate fn markdown_links(md: &str) -> Vec<MarkdownLink> {
     // There's no need to thread an IdMap through to here because
     // the IDs generated aren't going to be emitted anywhere.
     let mut ids = IdMap::new();
-    let iter = Footnotes::new(HeadingLinks::new(p, None, &mut ids, HeadingOffset::H1));
+    let iter =
+        Footnotes::new(HeadingLinks::new(p, None, &mut ids, HeadingOffset::H1, IdPrefix::none()));
 
     for ev in iter {
         if let Event::Start(Tag::Link(kind, dest, _)) = ev.0 {
@@ -1430,68 +1445,70 @@ crate fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_>) -> Vec<RustCodeB
     code_blocks
 }
 
+/// This wrapper exists only to allow the error_index_generator tool to use it.
+#[derive(Debug, Clone, Copy)]
+pub struct IdPrefix<'a>(IdPrefixInner<'a>);
+
+impl<'a> IdPrefix<'a> {
+    crate fn without_parent() -> Self {
+        Self(IdPrefixInner::WithoutParent)
+    }
+
+    pub fn none() -> Self {
+        Self(IdPrefixInner::None)
+    }
+
+    crate fn some(item: &'a clean::Item) -> Self {
+        Self(IdPrefixInner::Some(item))
+    }
+}
+
+/// Depending if we're generating a link for a markdown file or on a Rust type, we don't want the
+/// same behaviour:
+///
+/// In Rust, to reduce the number of "conflict" between HTML IDs, we add a prefix to them based on
+/// their parent. However, it is useless if rustdoc is used to render a markdown file.
+#[derive(Debug, Clone, Copy)]
+crate enum IdPrefixInner<'a> {
+    /// Contains the "parent" of the ID. It's used to generate the prefix.
+    Some(&'a clean::Item),
+    /// This is used in case markdown is inserted using `--markdown-before-content` or using
+    /// `--markdown-after-content`.
+    WithoutParent,
+    None,
+}
+
 #[derive(Clone, Default, Debug)]
 pub struct IdMap {
     map: FxHashMap<String, usize>,
 }
 
-fn init_id_map() -> FxHashMap<String, usize> {
-    let mut map = FxHashMap::default();
-    // This is the list of IDs used in Javascript.
-    map.insert("help".to_owned(), 1);
-    // This is the list of IDs used in HTML generated in Rust (including the ones
-    // used in tera template files).
-    map.insert("mainThemeStyle".to_owned(), 1);
-    map.insert("themeStyle".to_owned(), 1);
-    map.insert("theme-picker".to_owned(), 1);
-    map.insert("theme-choices".to_owned(), 1);
-    map.insert("settings-menu".to_owned(), 1);
-    map.insert("help-button".to_owned(), 1);
-    map.insert("main-content".to_owned(), 1);
-    map.insert("search".to_owned(), 1);
-    map.insert("crate-search".to_owned(), 1);
-    map.insert("render-detail".to_owned(), 1);
-    map.insert("toggle-all-docs".to_owned(), 1);
-    map.insert("all-types".to_owned(), 1);
-    map.insert("default-settings".to_owned(), 1);
-    map.insert("rustdoc-vars".to_owned(), 1);
-    map.insert("sidebar-vars".to_owned(), 1);
-    map.insert("copy-path".to_owned(), 1);
-    map.insert("TOC".to_owned(), 1);
-    // This is the list of IDs used by rustdoc sections (but still generated by
-    // rustdoc).
-    map.insert("fields".to_owned(), 1);
-    map.insert("variants".to_owned(), 1);
-    map.insert("implementors-list".to_owned(), 1);
-    map.insert("synthetic-implementors-list".to_owned(), 1);
-    map.insert("foreign-impls".to_owned(), 1);
-    map.insert("implementations".to_owned(), 1);
-    map.insert("trait-implementations".to_owned(), 1);
-    map.insert("synthetic-implementations".to_owned(), 1);
-    map.insert("blanket-implementations".to_owned(), 1);
-    map.insert("associated-types".to_owned(), 1);
-    map.insert("associated-const".to_owned(), 1);
-    map.insert("required-methods".to_owned(), 1);
-    map.insert("provided-methods".to_owned(), 1);
-    map.insert("implementors".to_owned(), 1);
-    map.insert("synthetic-implementors".to_owned(), 1);
-    map.insert("trait-implementations-list".to_owned(), 1);
-    map.insert("synthetic-implementations-list".to_owned(), 1);
-    map.insert("blanket-implementations-list".to_owned(), 1);
-    map.insert("deref-methods".to_owned(), 1);
-    map
-}
-
 impl IdMap {
     pub fn new() -> Self {
-        IdMap { map: init_id_map() }
+        IdMap { map: FxHashMap::default() }
     }
 
-    crate fn derive<S: AsRef<str> + ToString>(&mut self, candidate: S) -> String {
-        let id = match self.map.get_mut(candidate.as_ref()) {
-            None => candidate.to_string(),
+    crate fn derive<S: AsRef<str> + ToString>(
+        &mut self,
+        candidate: S,
+        id_prefix: IdPrefix<'_>,
+    ) -> String {
+        let candidate = match id_prefix.0 {
+            IdPrefixInner::None => candidate.to_string(),
+            IdPrefixInner::WithoutParent => format!("top.{}", candidate.as_ref()),
+            IdPrefixInner::Some(item) => {
+                let prefix = if let Some(name) = item.name {
+                    format!("{}.{}", item.type_(), name)
+                } else {
+                    format!("{}.unknown", item.type_())
+                };
+                format!("{}.{}", prefix, candidate.as_ref())
+            }
+        };
+        let id = match self.map.get_mut(&candidate) {
+            None => candidate,
             Some(a) => {
-                let id = format!("{}-{}", candidate.as_ref(), *a);
+                let id = format!("{}-{}", candidate, *a);
                 *a += 1;
                 id
             }

src/librustdoc/html/markdown/tests.rs

@@ -1,5 +1,7 @@
 use super::{find_testable_code, plain_text_summary, short_markdown_summary};
-use super::{ErrorCodes, HeadingOffset, IdMap, Ignore, LangString, Markdown, MarkdownHtml};
+use super::{
+    ErrorCodes, HeadingOffset, IdMap, IdPrefix, Ignore, LangString, Markdown, MarkdownHtml,
+};
 use rustc_span::edition::{Edition, DEFAULT_EDITION};
 
 #[test]
@@ -28,8 +30,8 @@ fn test_unique_id() {
         "examples-2",
         "method.into_iter-1",
         "foo-1",
-        "main-content-1",
-        "search-1",
+        "main-content",
+        "search",
         "methods",
         "examples-3",
         "method.into_iter-2",
@@ -38,7 +40,8 @@ fn test_unique_id() {
     ];
 
     let mut map = IdMap::new();
-    let actual: Vec<String> = input.iter().map(|s| map.derive(s.to_string())).collect();
+    let actual: Vec<String> =
+        input.iter().map(|s| map.derive(s.to_string(), IdPrefix::none())).collect();
     assert_eq!(&actual[..], expected);
 }
 
@@ -155,6 +158,7 @@ fn test_header() {
             edition: DEFAULT_EDITION,
             playground: &None,
             heading_offset: HeadingOffset::H2,
+            id_prefix: IdPrefix::none(),
         }
         .into_string();
         assert_eq!(output, expect, "original: {}", input);
@@ -197,6 +201,7 @@ fn test_header_ids_multiple_blocks() {
             edition: DEFAULT_EDITION,
             playground: &None,
             heading_offset: HeadingOffset::H2,
+            id_prefix: IdPrefix::none(),
         }
         .into_string();
         assert_eq!(output, expect, "original: {}", input);
@@ -220,7 +225,7 @@ fn test_header_ids_multiple_blocks() {
     t(
         &mut map,
         "# Search",
-        "<h2 id=\"search-1\" class=\"section-header\"><a href=\"#search-1\">Search</a></h2>",
+        "<h2 id=\"search\" class=\"section-header\"><a href=\"#search\">Search</a></h2>",
     );
     t(
         &mut map,
@@ -307,8 +312,15 @@ fn test_plain_text_summary() {
 fn test_markdown_html_escape() {
     fn t(input: &str, expect: &str) {
         let mut idmap = IdMap::new();
-        let output =
-            MarkdownHtml(input, &mut idmap, ErrorCodes::Yes, DEFAULT_EDITION, &None).into_string();
+        let output = MarkdownHtml(
+            input,
+            &mut idmap,
+            ErrorCodes::Yes,
+            DEFAULT_EDITION,
+            &None,
+            IdPrefix::none(),
+        )
+        .into_string();
         assert_eq!(output, expect, "original: {}", input);
     }
 

src/librustdoc/html/render/context.rs

@@ -31,7 +31,7 @@ use crate::formats::item_type::ItemType;
 use crate::formats::FormatRenderer;
 use crate::html::escape::Escape;
 use crate::html::format::Buffer;
-use crate::html::markdown::{self, plain_text_summary, ErrorCodes, IdMap};
+use crate::html::markdown::{self, plain_text_summary, ErrorCodes, IdMap, IdPrefix};
 use crate::html::{layout, sources};
 use crate::scrape_examples::AllCallLocations;
 use crate::try_err;
@@ -168,7 +168,7 @@ impl<'tcx> Context<'tcx> {
 
     pub(super) fn derive_id(&self, id: String) -> String {
         let mut map = self.id_map.borrow_mut();
-        map.derive(id)
+        map.derive(id, IdPrefix::none())
     }
 
     /// String representation of how to get back to the root path of the 'doc/'

src/librustdoc/html/render/mod.rs

@@ -74,7 +74,7 @@ use crate::html::format::{
     print_generic_bounds, print_where_clause, Buffer, HrefError, PrintWithSpace,
 };
 use crate::html::highlight;
-use crate::html::markdown::{HeadingOffset, Markdown, MarkdownHtml, MarkdownSummaryLine};
+use crate::html::markdown::{HeadingOffset, IdPrefix, Markdown, MarkdownHtml, MarkdownSummaryLine};
 use crate::html::sources;
 use crate::scrape_examples::{CallData, CallLocation};
 use crate::try_none;
@@ -493,6 +493,7 @@ fn render_markdown(
     md_text: &str,
     links: Vec<RenderedLink>,
     heading_offset: HeadingOffset,
+    item: &clean::Item,
 ) {
     let mut ids = cx.id_map.borrow_mut();
     write!(
@@ -506,6 +507,7 @@ fn render_markdown(
             edition: cx.shared.edition(),
             playground: &cx.shared.playground,
             heading_offset,
+            id_prefix: IdPrefix::some(item),
         }
         .into_string()
     )
@@ -576,10 +578,10 @@ fn document_full_inner(
                      <span>Expand description</span>\
                 </summary>",
             );
-            render_markdown(w, cx, &s, item.links(cx), heading_offset);
+            render_markdown(w, cx, &s, item.links(cx), heading_offset, item);
             w.write_str("</details>");
         } else {
-            render_markdown(w, cx, &s, item.links(cx), heading_offset);
+            render_markdown(w, cx, &s, item.links(cx), heading_offset, item);
         }
     }
 
@@ -663,6 +665,7 @@ fn short_item_info(
                 error_codes,
                 cx.shared.edition(),
                 &cx.shared.playground,
+                IdPrefix::some(item),
             );
             message.push_str(&format!(": {}", html.into_string()));
         }
@@ -1624,7 +1627,8 @@ fn render_impl(
                     error_codes: cx.shared.codes,
                     edition: cx.shared.edition(),
                     playground: &cx.shared.playground,
-                    heading_offset: HeadingOffset::H4
+                    heading_offset: HeadingOffset::H4,
+                    id_prefix: IdPrefix::some(&i.impl_item),
                 }
                 .into_string()
             );
@@ -2570,7 +2574,7 @@ fn render_call_locations(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item) {
     };
 
     // Generate a unique ID so users can link to this section for a given method
-    let id = cx.id_map.borrow_mut().derive("scraped-examples");
+    let id = cx.id_map.borrow_mut().derive("scraped-examples", IdPrefix::some(item));
     write!(
         w,
         "<div class=\"docblock scraped-example-list\">\

src/librustdoc/markdown.rs

@@ -11,7 +11,7 @@ use crate::doctest::{Collector, GlobalTestOptions};
 use crate::html::escape::Escape;
 use crate::html::markdown;
 use crate::html::markdown::{
-    find_testable_code, ErrorCodes, HeadingOffset, IdMap, Markdown, MarkdownWithToc,
+    find_testable_code, ErrorCodes, HeadingOffset, IdMap, IdPrefix, Markdown, MarkdownWithToc,
 };
 
 /// Separate any lines at the start of the file that begin with `# ` or `%`.
@@ -70,7 +70,8 @@ crate fn render<P: AsRef<Path>>(
     let mut ids = IdMap::new();
     let error_codes = ErrorCodes::from(options.unstable_features.is_nightly_build());
     let text = if !options.markdown_no_toc {
-        MarkdownWithToc(text, &mut ids, error_codes, edition, &playground).into_string()
+        MarkdownWithToc(text, &mut ids, error_codes, edition, &playground, IdPrefix::none())
+            .into_string()
     } else {
         Markdown {
             content: text,
@@ -80,6 +81,7 @@ crate fn render<P: AsRef<Path>>(
             edition,
             playground: &playground,
             heading_offset: HeadingOffset::H1,
+            id_prefix: IdPrefix::none(),
         }
         .into_string()
     };

src/test/rustdoc/enum-headings.rs

@@ -3,23 +3,23 @@
 /// A token!
 /// # First
 /// Some following text...
-// @has - '//h2[@id="first"]' "First"
+// @has - '//h2[@id="enum.Token.first"]' "First"
 pub enum Token {
     /// A declaration!
     /// # Variant-First
     /// Some following text...
-    // @has - '//h4[@id="variant-first"]' "Variant-First"
+    // @has - '//h4[@id="variant.Declaration.variant-first"]' "Variant-First"
     Declaration {
         /// A version!
         /// # Variant-Field-First
         /// Some following text...
-        // @has - '//h5[@id="variant-field-first"]' "Variant-Field-First"
+        // @has - '//h5[@id="structfield.version.variant-field-first"]' "Variant-Field-First"
         version: String,
     },
     /// A Zoople!
     /// # Variant-First
     Zoople(
-        // @has - '//h5[@id="variant-tuple-field-first"]' "Variant-Tuple-Field-First"
+        // @has - '//h5[@id="structfield.0.variant-tuple-field-first"]' "Variant-Tuple-Field-First"
         /// Zoople's first variant!
         /// # Variant-Tuple-Field-First
         /// Some following text...
@@ -28,13 +28,13 @@ pub enum Token {
     /// Unfinished business!
     /// # Non-Exhaustive-First
     /// Some following text...
-    // @has - '//h4[@id="non-exhaustive-first"]' "Non-Exhaustive-First"
+    // @has - '//h4[@id="variant.Unfinished.non-exhaustive-first"]' "Non-Exhaustive-First"
     #[non_exhaustive]
     Unfinished {
         /// This is x.
         /// # X-First
         /// Some following text...
-        // @has - '//h5[@id="x-first"]' "X-First"
+        // @has - '//h5[@id="structfield.x.x-first"]' "X-First"
         x: usize,
     },
 }

src/test/rustdoc/issue-29449.rs

@@ -2,18 +2,20 @@
 pub struct Foo;
 
 impl Foo {
-    // @has - '//*[@id="examples"]//a' 'Examples'
-    // @has - '//*[@id="panics"]//a' 'Panics'
+    // @has - '//*[@id="method.bar.examples"]//a' 'Examples'
+    // @has - '//*[@id="method.bar.panics"]//a' 'Panics'
     /// # Examples
     /// # Panics
     pub fn bar() {}
 
-    // @has - '//*[@id="examples-1"]//a' 'Examples'
+    // @has - '//*[@id="method.bar_1.examples"]//a' 'Examples'
+    // @has - '//*[@id="method.bar_1.examples-1"]//a' 'Examples'
+    /// # Examples
     /// # Examples
     pub fn bar_1() {}
 
-    // @has - '//*[@id="examples-2"]//a' 'Examples'
-    // @has - '//*[@id="panics-1"]//a' 'Panics'
+    // @has - '//*[@id="method.bar_2.examples"]//a' 'Examples'
+    // @has - '//*[@id="method.bar_2.panics"]//a' 'Panics'
     /// # Examples
     /// # Panics
     pub fn bar_2() {}

src/test/rustdoc/remove-url-from-headings.rs

@@ -2,8 +2,8 @@
 
 // @has foo/fn.foo.html
 // @!has - '//a[@href="http://a.a"]'
-// @has - '//a[@href="#implementing-stuff-somewhere"]' 'Implementing stuff somewhere'
-// @has - '//a[@href="#another-one-urg"]' 'Another one urg'
+// @has - '//a[@href="#fn.foo.implementing-stuff-somewhere"]' 'Implementing stuff somewhere'
+// @has - '//a[@href="#fn.foo.another-one-urg"]' 'Another one urg'
 
 /// fooo
 ///

src/test/rustdoc/short-docblock.rs

@@ -2,7 +2,7 @@
 
 // @has foo/index.html '//*[@class="item-right docblock-short"]/p' 'fooo'
 // @!has foo/index.html '//*[@class="item-right docblock-short"]/p/h1' 'fooo'
-// @has foo/fn.foo.html '//h2[@id="fooo"]/a[@href="#fooo"]' 'fooo'
+// @has foo/fn.foo.html '//h2[@id="fn.foo.fooo"]/a[@href="#fn.foo.fooo"]' 'fooo'
 
 /// # fooo
 ///
@@ -11,7 +11,7 @@ pub fn foo() {}
 
 // @has foo/index.html '//*[@class="item-right docblock-short"]/p' 'mooood'
 // @!has foo/index.html '//*[@class="item-right docblock-short"]/p/h2' 'mooood'
-// @has foo/foo/index.html '//h3[@id="mooood"]/a[@href="#mooood"]' 'mooood'
+// @has foo/foo/index.html '//h3[@id="mod.foo.mooood"]/a[@href="#mod.foo.mooood"]' 'mooood'
 
 /// ## mooood
 ///

src/tools/error_index_generator/main.rs

@@ -14,7 +14,7 @@ use std::path::PathBuf;
 
 use rustc_span::edition::DEFAULT_EDITION;
 
-use rustdoc::html::markdown::{ErrorCodes, HeadingOffset, IdMap, Markdown, Playground};
+use rustdoc::html::markdown::{ErrorCodes, HeadingOffset, IdMap, IdPrefix, Markdown, Playground};
 
 pub struct ErrorMetadata {
     pub description: Option<String>,
@@ -127,6 +127,7 @@ impl Formatter for HTMLFormatter {
                         edition: DEFAULT_EDITION,
                         playground: &Some(playground),
                         heading_offset: HeadingOffset::H1,
+                        id_prefix: IdPrefix::none(),
                     }
                     .into_string()
                 )?