Auto merge of rust-lang#136816 - yotamofek:pr/notable-traits-button-cleanup, r=<try>

Optimize `notable_trait_buttons`

~Small cleanup.
Use `Iterator::any` instead of `for` loop with `predicate = true;`.
I think this makes the code more readable... and also has the additional benefit of short-circuiting the iterator when a notable trait is found (a `break` statement was missing in the `for` loop version, I think). Probably won't be significant enough to show on perf results, though.~

Three commits, each attempting to optimize `notable_trait_buttons` by a little bit.

Author: bors

src/librustdoc/html/render/context.rs

@@ -5,7 +5,7 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{Receiver, channel};
 
 use rinja::Template;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_hir::def_id::{DefIdMap, LOCAL_CRATE};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
@@ -60,7 +60,7 @@ pub(crate) struct Context<'tcx> {
     /// [#82381]: https://github.com/rust-lang/rust/issues/82381
     pub(crate) shared: SharedContext<'tcx>,
     /// Collection of all types with notable traits referenced in the current module.
-    pub(crate) types_with_notable_traits: RefCell<FxIndexSet<clean::Type>>,
+    pub(crate) types_with_notable_traits: RefCell<FxHashSet<clean::Type>>,
     /// Contains information that needs to be saved and reset after rendering an item which is
     /// not a module.
     pub(crate) info: ContextInfo,
@@ -579,7 +579,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             id_map: RefCell::new(id_map),
             deref_id_map: Default::default(),
             shared: scx,
-            types_with_notable_traits: RefCell::new(FxIndexSet::default()),
+            types_with_notable_traits: RefCell::default(),
             info: ContextInfo::new(include_sources),
         };
 

src/librustdoc/html/render/mod.rs

@@ -1432,56 +1432,57 @@ fn should_render_item(item: &clean::Item, deref_mut_: bool, tcx: TyCtxt<'_>) ->
 }
 
 pub(crate) fn notable_traits_button(ty: &clean::Type, cx: &Context<'_>) -> Option<String> {
-    let mut has_notable_trait = false;
-
     if ty.is_unit() {
         // Very common fast path.
         return None;
     }
 
-    let did = ty.def_id(cx.cache())?;
+    let has_notable_trait = || {
+        let Some(did) = ty.def_id(cx.cache()) else {
+            return false;
+        };
 
-    // Box has pass-through impls for Read, Write, Iterator, and Future when the
-    // boxed type implements one of those. We don't want to treat every Box return
-    // as being notably an Iterator (etc), though, so we exempt it. Pin has the same
-    // issue, with a pass-through impl for Future.
-    if Some(did) == cx.tcx().lang_items().owned_box()
-        || Some(did) == cx.tcx().lang_items().pin_type()
-    {
-        return None;
-    }
+        // Box has pass-through impls for Read, Write, Iterator, and Future when the
+        // boxed type implements one of those. We don't want to treat every Box return
+        // as being notably an Iterator (etc), though, so we exempt it. Pin has the same
+        // issue, with a pass-through impl for Future.
+        if Some(did) == cx.tcx().lang_items().owned_box()
+            || Some(did) == cx.tcx().lang_items().pin_type()
+        {
+            return false;
+        }
 
-    if let Some(impls) = cx.cache().impls.get(&did) {
-        for i in impls {
-            let impl_ = i.inner_impl();
-            if impl_.polarity != ty::ImplPolarity::Positive {
-                continue;
-            }
+        let Some(impls) = cx.cache().impls.get(&did) else {
+            return false;
+        };
 
-            if !ty.is_doc_subtype_of(&impl_.for_, cx.cache()) {
-                // Two different types might have the same did,
-                // without actually being the same.
-                continue;
-            }
-            if let Some(trait_) = &impl_.trait_ {
-                let trait_did = trait_.def_id();
+        impls
+            .iter()
+            .map(Impl::inner_impl)
+            .filter(|impl_| {
+                impl_.polarity == ty::ImplPolarity::Positive
+                    // Two different types might have the same did,
+                    // without actually being the same.
+                    && ty.is_doc_subtype_of(&impl_.for_, cx.cache())
+            })
+            .filter_map(|impl_| impl_.trait_.as_ref())
+            .filter_map(|trait_| cx.cache().traits.get(&trait_.def_id()))
+            .any(|t| t.is_notable_trait(cx.tcx()))
+    };
 
-                if cx.cache().traits.get(&trait_did).is_some_and(|t| t.is_notable_trait(cx.tcx())) {
-                    has_notable_trait = true;
-                }
-            }
+    let mut types_with_notable_traits = cx.types_with_notable_traits.borrow_mut();
+    if !types_with_notable_traits.contains(ty) {
+        if has_notable_trait() {
+            types_with_notable_traits.insert(ty.clone());
+        } else {
+            return None;
         }
     }
 
-    if has_notable_trait {
-        cx.types_with_notable_traits.borrow_mut().insert(ty.clone());
-        Some(format!(
-            " <a href=\"#\" class=\"tooltip\" data-notable-ty=\"{ty}\">ⓘ</a>",
-            ty = Escape(&format!("{:#}", ty.print(cx))),
-        ))
-    } else {
-        None
-    }
+    Some(format!(
+        " <a href=\"#\" class=\"tooltip\" data-notable-ty=\"{ty}\">ⓘ</a>",
+        ty = Escape(&format!("{:#}", ty.print(cx))),
+    ))
 }
 
 fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
@@ -1544,10 +1545,10 @@ fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
     (format!("{:#}", ty.print(cx)), out.into_inner())
 }
 
-pub(crate) fn notable_traits_json<'a>(
-    tys: impl Iterator<Item = &'a clean::Type>,
-    cx: &Context<'_>,
-) -> String {
+pub(crate) fn notable_traits_json(tys: &FxHashSet<clean::Type>, cx: &Context<'_>) -> String {
+    #[expect(rustc::potential_query_instability, reason = "items are sorted by name")]
+    let tys = tys.iter();
+
     let mut mp: Vec<(String, String)> = tys.map(|ty| notable_traits_decl(ty, cx)).collect();
     mp.sort_by(|(name1, _html1), (name2, _html2)| name1.cmp(name2));
     struct NotableTraitsMap(Vec<(String, String)>);

src/librustdoc/html/render/print_item.rs

@@ -281,7 +281,7 @@ pub(super) fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer)
         write!(
             buf,
             r#"<script type="text/json" id="notable-traits-data">{}</script>"#,
-            notable_traits_json(types_with_notable_traits.iter(), cx)
+            notable_traits_json(&types_with_notable_traits, cx)
         );
         types_with_notable_traits.clear();
     }