diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs index ff87baeef3e66..73d6566e3cd97 100644 --- a/compiler/rustc_resolve/src/late.rs +++ b/compiler/rustc_resolve/src/late.rs @@ -182,7 +182,7 @@ impl RibKind<'_> { /// stack. This may be, for example, a `let` statement (because it introduces variables), a macro, /// etc. /// -/// Different [rib kinds](enum.RibKind) are transparent for different names. +/// Different [rib kinds](enum@RibKind) are transparent for different names. /// /// The resolution keeps a separate stack of ribs as it traverses the AST for each namespace. When /// resolving, the name is looked up from inside out. diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index e7b966758d6e0..1ccd6a2c0ef28 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -544,7 +544,7 @@ fn build_module( segments: vec![clean::PathSegment { name: prim_ty.as_sym(), args: clean::GenericArgs::AngleBracketed { - args: Vec::new(), + args: Default::default(), bindings: ThinVec::new(), }, }], diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 04d97e0dabfa0..9d5619bacf516 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -420,7 +420,7 @@ fn projection_to_path_segment(ty: ty::ProjectionTy<'_>, cx: &mut DocContext<'_>) PathSegment { name: item.name, args: GenericArgs::AngleBracketed { - args: substs_to_args(cx, &ty.substs[generics.parent_count..], false), + args: substs_to_args(cx, &ty.substs[generics.parent_count..], false).into(), bindings: Default::default(), }, } @@ -1205,7 +1205,7 @@ impl Clean for ty::AssocItem { || generics .params .iter() - .zip(args) + .zip(args.iter()) .any(|(param, arg)| !param_eq_arg(param, arg)) { return false; @@ -1837,7 +1837,7 @@ impl Clean for hir::GenericArgs<'_> { let output = self.bindings[0].ty().clean(cx); let output = if output != Type::Tuple(Vec::new()) { Some(Box::new(output)) } else { None }; - let inputs = self.inputs().iter().map(|x| x.clean(cx)).collect(); + let inputs = self.inputs().iter().map(|x| x.clean(cx)).collect::>().into(); GenericArgs::Parenthesized { inputs, output } } else { let args = self @@ -1852,8 +1852,9 @@ impl Clean for hir::GenericArgs<'_> { hir::GenericArg::Const(ct) => GenericArg::Const(Box::new(ct.clean(cx))), hir::GenericArg::Infer(_inf) => GenericArg::Infer, }) - .collect(); - let bindings = self.bindings.iter().map(|x| x.clean(cx)).collect(); + .collect::>() + .into(); + let bindings = self.bindings.iter().map(|x| x.clean(cx)).collect::>().into(); GenericArgs::AngleBracketed { args, bindings } } } diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index a832d03a5011f..1bb0219c42a3e 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -994,7 +994,7 @@ pub(crate) struct DocFragment { #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] rustc_data_structures::static_assert_size!(DocFragment, 32); -#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] +#[derive(Clone, Copy, PartialEq, Eq, Debug)] pub(crate) enum DocFragmentKind { /// A doc fragment created from a `///` or `//!` doc comment. SugaredDoc, @@ -2182,14 +2182,14 @@ rustc_data_structures::static_assert_size!(GenericArg, 80); #[derive(Clone, PartialEq, Eq, Debug, Hash)] pub(crate) enum GenericArgs { - AngleBracketed { args: Vec, bindings: ThinVec }, - Parenthesized { inputs: Vec, output: Option> }, + AngleBracketed { args: Box<[GenericArg]>, bindings: ThinVec }, + Parenthesized { inputs: Box<[Type]>, output: Option> }, } // `GenericArgs` is in every `PathSegment`, so its size can significantly // affect rustdoc's memory usage. #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(GenericArgs, 40); +rustc_data_structures::static_assert_size!(GenericArgs, 32); #[derive(Clone, PartialEq, Eq, Debug, Hash)] pub(crate) struct PathSegment { @@ -2200,7 +2200,7 @@ pub(crate) struct PathSegment { // `PathSegment` usually occurs multiple times in every `Path`, so its size can // significantly affect rustdoc's memory usage. #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))] -rustc_data_structures::static_assert_size!(PathSegment, 48); +rustc_data_structures::static_assert_size!(PathSegment, 40); #[derive(Clone, Debug)] pub(crate) struct Typedef { diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 7a12ea0d5c215..47597e0413ae1 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -80,23 +80,23 @@ pub(crate) fn substs_to_args( substs: &[ty::subst::GenericArg<'_>], mut skip_first: bool, ) -> Vec { - substs - .iter() - .filter_map(|kind| match kind.unpack() { - GenericArgKind::Lifetime(lt) => match *lt { - ty::ReLateBound(_, ty::BoundRegion { kind: ty::BrAnon(_), .. }) => { - Some(GenericArg::Lifetime(Lifetime::elided())) - } - _ => lt.clean(cx).map(GenericArg::Lifetime), - }, - GenericArgKind::Type(_) if skip_first => { - skip_first = false; - None + let mut ret_val = + Vec::with_capacity(substs.len().saturating_sub(if skip_first { 1 } else { 0 })); + ret_val.extend(substs.iter().filter_map(|kind| match kind.unpack() { + GenericArgKind::Lifetime(lt) => match *lt { + ty::ReLateBound(_, ty::BoundRegion { kind: ty::BrAnon(_), .. }) => { + Some(GenericArg::Lifetime(Lifetime::elided())) } - GenericArgKind::Type(ty) => Some(GenericArg::Type(ty.clean(cx))), - GenericArgKind::Const(ct) => Some(GenericArg::Const(Box::new(ct.clean(cx)))), - }) - .collect() + _ => lt.clean(cx).map(GenericArg::Lifetime), + }, + GenericArgKind::Type(_) if skip_first => { + skip_first = false; + None + } + GenericArgKind::Type(ty) => Some(GenericArg::Type(ty.clean(cx))), + GenericArgKind::Const(ct) => Some(GenericArg::Const(Box::new(ct.clean(cx)))), + })); + ret_val } fn external_generic_args( @@ -112,8 +112,8 @@ fn external_generic_args( let inputs = // The trait's first substitution is the one after self, if there is one. match substs.iter().nth(if has_self { 1 } else { 0 }).unwrap().expect_ty().kind() { - ty::Tuple(tys) => tys.iter().map(|t| t.clean(cx)).collect(), - _ => return GenericArgs::AngleBracketed { args, bindings: bindings.into() }, + ty::Tuple(tys) => tys.iter().map(|t| t.clean(cx)).collect::>().into(), + _ => return GenericArgs::AngleBracketed { args: args.into(), bindings: bindings.into() }, }; let output = None; // FIXME(#20299) return type comes from a projection now @@ -123,7 +123,7 @@ fn external_generic_args( // }; GenericArgs::Parenthesized { inputs, output } } else { - GenericArgs::AngleBracketed { args, bindings: bindings.into() } + GenericArgs::AngleBracketed { args: args.into(), bindings: bindings.into() } } } @@ -148,7 +148,7 @@ pub(super) fn external_path( /// Remove the generic arguments from a path. pub(crate) fn strip_path_generics(mut path: Path) -> Path { for ps in path.segments.iter_mut() { - ps.args = GenericArgs::AngleBracketed { args: vec![], bindings: ThinVec::new() } + ps.args = GenericArgs::AngleBracketed { args: Default::default(), bindings: ThinVec::new() } } path diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 1214e4367c2f8..da32d8c90be64 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -457,7 +457,7 @@ impl clean::GenericArgs { f.write_str("<")?; } let mut comma = false; - for arg in args { + for arg in args.iter() { if comma { f.write_str(", ")?; } @@ -468,7 +468,7 @@ impl clean::GenericArgs { write!(f, "{}", arg.print(cx))?; } } - for binding in bindings { + for binding in bindings.iter() { if comma { f.write_str(", ")?; } @@ -489,7 +489,7 @@ impl clean::GenericArgs { clean::GenericArgs::Parenthesized { inputs, output } => { f.write_str("(")?; let mut comma = false; - for ty in inputs { + for ty in inputs.iter() { if comma { f.write_str(", ")?; } diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs index 6f6f7e375a425..bc9920730dd3c 100644 --- a/src/librustdoc/json/conversions.rs +++ b/src/librustdoc/json/conversions.rs @@ -119,11 +119,11 @@ impl FromWithTcx for GenericArgs { use clean::GenericArgs::*; match args { AngleBracketed { args, bindings } => GenericArgs::AngleBracketed { - args: args.into_iter().map(|a| a.into_tcx(tcx)).collect(), + args: args.into_vec().into_iter().map(|a| a.into_tcx(tcx)).collect(), bindings: bindings.into_iter().map(|a| a.into_tcx(tcx)).collect(), }, Parenthesized { inputs, output } => GenericArgs::Parenthesized { - inputs: inputs.into_iter().map(|a| a.into_tcx(tcx)).collect(), + inputs: inputs.into_vec().into_iter().map(|a| a.into_tcx(tcx)).collect(), output: output.map(|a| (*a).into_tcx(tcx)), }, }