Make {Type,Path}::generics return iterators.

Instead of a `Vec`, to avoid some allocations.

Author: nnethercote

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
             }

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:#}<")?;