From 750f57fafe43a07758ecf8e2622ebba2967966ae Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 23 May 2025 13:42:10 +1000
Subject: [PATCH] Make `{Type,Path}::generics` return iterators.

Instead of a `Vec`, to avoid some allocations.
---
 src/librustdoc/clean/types.rs | 20 +++++++-------------
 src/librustdoc/html/format.rs |  9 ++++-----
 2 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 07ecd98f7759..bfc02b6b1d42 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1601,9 +1601,7 @@ impl Type {
                 a.def_id() == b.def_id()
                     && a.generics()
                         .zip(b.generics())
-                        .map(|(ag, bg)| {
-                            ag.iter().zip(bg.iter()).all(|(at, bt)| at.is_doc_subtype_of(bt, cache))
-                        })
+                        .map(|(ag, bg)| ag.zip(bg).all(|(at, bt)| at.is_doc_subtype_of(bt, cache)))
                         .unwrap_or(true)
             }
             // Other cases, such as primitives, just use recursion.
@@ -1676,7 +1674,7 @@ impl Type {
         }
     }
 
-    pub(crate) fn generics(&self) -> Option<Vec<&Type>> {
+    pub(crate) fn generics<'a>(&'a self) -> Option<impl Iterator<Item = &'a Type>> {
         match self {
             Type::Path { path, .. } => path.generics(),
             _ => None,
@@ -2234,17 +2232,13 @@ impl Path {
         self.segments.last().map(|seg| &seg.args)
     }
 
-    pub(crate) fn generics(&self) -> Option<Vec<&Type>> {
+    pub(crate) fn generics<'a>(&'a self) -> Option<impl Iterator<Item = &'a Type>> {
         self.segments.last().and_then(|seg| {
             if let GenericArgs::AngleBracketed { ref args, .. } = seg.args {
-                Some(
-                    args.iter()
-                        .filter_map(|arg| match arg {
-                            GenericArg::Type(ty) => Some(ty),
-                            _ => None,
-                        })
-                        .collect(),
-                )
+                Some(args.iter().filter_map(|arg| match arg {
+                    GenericArg::Type(ty) => Some(ty),
+                    _ => None,
+                }))
             } else {
                 None
             }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 1cb6e89218af..0d7a409d481a 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -1119,8 +1119,8 @@ impl clean::Impl {
                     write!(f, "!")?;
                 }
                 if self.kind.is_fake_variadic()
-                    && let generics = ty.generics()
-                    && let &[inner_type] = generics.as_ref().map_or(&[][..], |v| &v[..])
+                    && let Some(mut generics) = ty.generics()
+                    && let (Some(inner_type), None) = (generics.next(), generics.next())
                 {
                     let last = ty.last();
                     if f.alternate() {
@@ -1198,11 +1198,10 @@ impl clean::Impl {
                 fmt_type(&bare_fn.decl.output, f, use_absolute, cx)?;
             }
         } else if let clean::Type::Path { path } = type_
-            && let Some(generics) = path.generics()
-            && generics.len() == 1
+            && let Some(mut generics) = path.generics()
+            && let (Some(ty), None) = (generics.next(), generics.next())
             && self.kind.is_fake_variadic()
         {
-            let ty = generics[0];
             let wrapper = print_anchor(path.def_id(), path.last(), cx);
             if f.alternate() {
                 write!(f, "{wrapper:#}&lt;")?;