Auto merge of rust-lang#133345 - GuillaumeGomez:stop-cloning-context, r=<try>

Stop cloning `Context` so much

This is a first step for rust-lang#82381.

It's already big enough so I'll continue in a follow-up once this PR is merged. Next step will be to get rid of `SharedContext` by inlining it directly into `Context`.

cc `@camelid`
r? `@notriddle`

Author: bors

src/librustdoc/formats/renderer.rs

@@ -1,5 +1,5 @@
+use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_middle::ty::TyCtxt;
-use tracing::debug;
 
 use crate::clean;
 use crate::config::RenderOptions;
@@ -17,6 +17,7 @@ pub(crate) trait FormatRenderer<'tcx>: Sized {
     ///
     /// This is true for html, and false for json. See #80664
     const RUN_ON_MODULE: bool;
+    type InfoType;
 
     /// Sets up any state required for the renderer. When this is called the cache has already been
     /// populated.
@@ -28,7 +29,8 @@ pub(crate) trait FormatRenderer<'tcx>: Sized {
     ) -> Result<(Self, clean::Crate), Error>;
 
     /// Make a new renderer to render a child of the item currently being rendered.
-    fn make_child_renderer(&self) -> Self;
+    fn make_child_renderer(&mut self) -> Self::InfoType;
+    fn set_back_info(&mut self, _info: Self::InfoType);
 
     /// Renders a single non-module item. This means no recursive sub-item rendering is required.
     fn item(&mut self, item: clean::Item) -> Result<(), Error>;
@@ -47,6 +49,40 @@ pub(crate) trait FormatRenderer<'tcx>: Sized {
     fn cache(&self) -> &Cache;
 }
 
+fn run_format_inner<'tcx, T: FormatRenderer<'tcx>>(
+    cx: &mut T,
+    item: clean::Item,
+    prof: &SelfProfilerRef,
+) -> Result<(), Error> {
+    if item.is_mod() && T::RUN_ON_MODULE {
+        // modules are special because they add a namespace. We also need to
+        // recurse into the items of the module as well.
+        let _timer =
+            prof.generic_activity_with_arg("render_mod_item", item.name.unwrap().to_string());
+
+        cx.mod_item_in(&item)?;
+        let (clean::StrippedItem(box clean::ModuleItem(module)) | clean::ModuleItem(module)) =
+            item.inner.kind
+        else {
+            unreachable!()
+        };
+        for it in module.items {
+            let info = cx.make_child_renderer();
+            run_format_inner(cx, it, prof)?;
+            cx.set_back_info(info);
+        }
+
+        cx.mod_item_out()?;
+    // FIXME: checking `item.name.is_some()` is very implicit and leads to lots of special
+    // cases. Use an explicit match instead.
+    } else if let Some(item_name) = item.name
+        && !item.is_extern_crate()
+    {
+        prof.generic_activity_with_arg("render_item", item_name.as_str()).run(|| cx.item(item))?;
+    }
+    Ok(())
+}
+
 /// Main method for rendering a crate.
 pub(crate) fn run_format<'tcx, T: FormatRenderer<'tcx>>(
     krate: clean::Crate,
@@ -66,36 +102,8 @@ pub(crate) fn run_format<'tcx, T: FormatRenderer<'tcx>>(
     }
 
     // Render the crate documentation
-    let mut work = vec![(format_renderer.make_child_renderer(), krate.module)];
-
-    while let Some((mut cx, item)) = work.pop() {
-        if item.is_mod() && T::RUN_ON_MODULE {
-            // modules are special because they add a namespace. We also need to
-            // recurse into the items of the module as well.
-            let _timer =
-                prof.generic_activity_with_arg("render_mod_item", item.name.unwrap().to_string());
-
-            cx.mod_item_in(&item)?;
-            let (clean::StrippedItem(box clean::ModuleItem(module)) | clean::ModuleItem(module)) =
-                item.inner.kind
-            else {
-                unreachable!()
-            };
-            for it in module.items {
-                debug!("Adding {:?} to worklist", it.name);
-                work.push((cx.make_child_renderer(), it));
-            }
-
-            cx.mod_item_out()?;
-        // FIXME: checking `item.name.is_some()` is very implicit and leads to lots of special
-        // cases. Use an explicit match instead.
-        } else if let Some(item_name) = item.name
-            && !item.is_extern_crate()
-        {
-            prof.generic_activity_with_arg("render_item", item_name.as_str())
-                .run(|| cx.item(item))?;
-        }
-    }
+    run_format_inner(&mut format_renderer, krate.module, prof)?;
+
     prof.verbose_generic_activity_with_arg("renderer_after_krate", T::descr())
         .run(|| format_renderer.after_krate())
 }

src/librustdoc/html/markdown.rs

@@ -32,12 +32,11 @@ use std::iter::Peekable;
 use std::ops::{ControlFlow, Range};
 use std::path::PathBuf;
 use std::str::{self, CharIndices};
-use std::sync::OnceLock;
 
 use pulldown_cmark::{
     BrokenLink, CodeBlockKind, CowStr, Event, LinkType, Options, Parser, Tag, TagEnd, html,
 };
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::{Diag, DiagMessage};
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::TyCtxt;
@@ -1886,74 +1885,81 @@ pub(crate) fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_>) -> Vec<Rust
 #[derive(Clone, Default, Debug)]
 pub struct IdMap {
     map: FxHashMap<Cow<'static, str>, usize>,
+    defined_ids: FxHashSet<&'static str>,
     existing_footnotes: usize,
 }
 
-// The map is pre-initialized and cloned each time to avoid reinitializing it repeatedly.
-static DEFAULT_ID_MAP: OnceLock<FxHashMap<Cow<'static, str>, usize>> = OnceLock::new();
-
-fn init_id_map() -> FxHashMap<Cow<'static, str>, usize> {
-    let mut map = FxHashMap::default();
+fn init_id_map() -> FxHashSet<&'static str> {
+    let mut map = FxHashSet::default();
     // This is the list of IDs used in JavaScript.
-    map.insert("help".into(), 1);
-    map.insert("settings".into(), 1);
-    map.insert("not-displayed".into(), 1);
-    map.insert("alternative-display".into(), 1);
-    map.insert("search".into(), 1);
-    map.insert("crate-search".into(), 1);
-    map.insert("crate-search-div".into(), 1);
+    map.insert("help");
+    map.insert("settings");
+    map.insert("not-displayed");
+    map.insert("alternative-display");
+    map.insert("search");
+    map.insert("crate-search");
+    map.insert("crate-search-div");
     // This is the list of IDs used in HTML generated in Rust (including the ones
     // used in tera template files).
-    map.insert("themeStyle".into(), 1);
-    map.insert("settings-menu".into(), 1);
-    map.insert("help-button".into(), 1);
-    map.insert("sidebar-button".into(), 1);
-    map.insert("main-content".into(), 1);
-    map.insert("toggle-all-docs".into(), 1);
-    map.insert("all-types".into(), 1);
-    map.insert("default-settings".into(), 1);
-    map.insert("sidebar-vars".into(), 1);
-    map.insert("copy-path".into(), 1);
-    map.insert("rustdoc-toc".into(), 1);
-    map.insert("rustdoc-modnav".into(), 1);
+    map.insert("themeStyle");
+    map.insert("settings-menu");
+    map.insert("help-button");
+    map.insert("sidebar-button");
+    map.insert("main-content");
+    map.insert("toggle-all-docs");
+    map.insert("all-types");
+    map.insert("default-settings");
+    map.insert("sidebar-vars");
+    map.insert("copy-path");
+    map.insert("rustdoc-toc");
+    map.insert("rustdoc-modnav");
     // This is the list of IDs used by rustdoc sections (but still generated by
     // rustdoc).
-    map.insert("fields".into(), 1);
-    map.insert("variants".into(), 1);
-    map.insert("implementors-list".into(), 1);
-    map.insert("synthetic-implementors-list".into(), 1);
-    map.insert("foreign-impls".into(), 1);
-    map.insert("implementations".into(), 1);
-    map.insert("trait-implementations".into(), 1);
-    map.insert("synthetic-implementations".into(), 1);
-    map.insert("blanket-implementations".into(), 1);
-    map.insert("required-associated-types".into(), 1);
-    map.insert("provided-associated-types".into(), 1);
-    map.insert("provided-associated-consts".into(), 1);
-    map.insert("required-associated-consts".into(), 1);
-    map.insert("required-methods".into(), 1);
-    map.insert("provided-methods".into(), 1);
-    map.insert("dyn-compatibility".into(), 1);
-    map.insert("implementors".into(), 1);
-    map.insert("synthetic-implementors".into(), 1);
-    map.insert("implementations-list".into(), 1);
-    map.insert("trait-implementations-list".into(), 1);
-    map.insert("synthetic-implementations-list".into(), 1);
-    map.insert("blanket-implementations-list".into(), 1);
-    map.insert("deref-methods".into(), 1);
-    map.insert("layout".into(), 1);
-    map.insert("aliased-type".into(), 1);
+    map.insert("fields");
+    map.insert("variants");
+    map.insert("implementors-list");
+    map.insert("synthetic-implementors-list");
+    map.insert("foreign-impls");
+    map.insert("implementations");
+    map.insert("trait-implementations");
+    map.insert("synthetic-implementations");
+    map.insert("blanket-implementations");
+    map.insert("required-associated-types");
+    map.insert("provided-associated-types");
+    map.insert("provided-associated-consts");
+    map.insert("required-associated-consts");
+    map.insert("required-methods");
+    map.insert("provided-methods");
+    map.insert("dyn-compatibility");
+    map.insert("implementors");
+    map.insert("synthetic-implementors");
+    map.insert("implementations-list");
+    map.insert("trait-implementations-list");
+    map.insert("synthetic-implementations-list");
+    map.insert("blanket-implementations-list");
+    map.insert("deref-methods");
+    map.insert("layout");
+    map.insert("aliased-type");
     map
 }
 
 impl IdMap {
     pub fn new() -> Self {
-        IdMap { map: DEFAULT_ID_MAP.get_or_init(init_id_map).clone(), existing_footnotes: 0 }
+        IdMap { map: FxHashMap::default(), defined_ids: init_id_map(), existing_footnotes: 0 }
     }
 
     pub(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(),
+            None => {
+                let candidate = candidate.to_string();
+                if self.defined_ids.contains(candidate.as_str()) {
+                    let id = format!("{}-{}", candidate, 1);
+                    self.map.insert(candidate.into(), 2);
+                    id
+                } else {
+                    candidate.to_string()
+                }
+            }
             Some(a) => {
                 let id = format!("{}-{}", candidate.as_ref(), *a);
                 *a += 1;
@@ -1973,4 +1979,9 @@ impl IdMap {
         closure(self, &mut existing_footnotes);
         self.existing_footnotes = existing_footnotes;
     }
+
+    pub(crate) fn clear(&mut self) {
+        self.map.clear();
+        self.existing_footnotes = 0;
+    }
 }