diff --git a/Cargo.lock b/Cargo.lock
index a912eee97dbf2..95466e5b14e3b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3800,6 +3800,7 @@ dependencies = [
  "stable_deref_trait",
  "stacker",
  "tempfile",
+ "thin-slice",
  "tracing",
  "winapi",
 ]
@@ -5247,6 +5248,12 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "thin-slice"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c"
+
 [[package]]
 name = "thiserror"
 version = "1.0.20"
diff --git a/compiler/rustc_data_structures/Cargo.toml b/compiler/rustc_data_structures/Cargo.toml
index e3395df35908c..17f3af491f6c4 100644
--- a/compiler/rustc_data_structures/Cargo.toml
+++ b/compiler/rustc_data_structures/Cargo.toml
@@ -27,6 +27,7 @@ measureme = "10.0.0"
 libc = "0.2"
 stacker = "0.1.14"
 tempfile = "3.2"
+thin-slice = "0.1.1"
 
 [dependencies.parking_lot]
 version = "0.11"
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 181e5180d53d5..a4e6d605e646d 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -103,6 +103,7 @@ pub mod steal;
 pub mod tagged_ptr;
 pub mod temp_dir;
 pub mod unhash;
+pub mod thin_slice;
 
 pub use ena::undo_log;
 pub use ena::unify;
diff --git a/compiler/rustc_data_structures/src/thin_slice.rs b/compiler/rustc_data_structures/src/thin_slice.rs
new file mode 100644
index 0000000000000..4d5362731f5d6
--- /dev/null
+++ b/compiler/rustc_data_structures/src/thin_slice.rs
@@ -0,0 +1,53 @@
+use std::ops::{Deref, DerefMut};
+use thin_slice::ThinBoxedSlice;
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct ThinSlice<T> {
+    slice: ThinBoxedSlice<T>,
+}
+
+impl<T> ThinSlice<T> {
+    pub fn into_vec(self) -> Vec<T> {
+        self.into()
+    }
+}
+
+impl<T> Default for ThinSlice<T> {
+    fn default() -> Self {
+        Self { slice: Default::default() }
+    }
+}
+
+impl<T> From<Vec<T>> for ThinSlice<T> {
+    fn from(vec: Vec<T>) -> Self {
+        Self { slice: vec.into_boxed_slice2().into() }
+    }
+}
+
+impl<T> From<ThinSlice<T>> for Vec<T> {
+    fn from(slice: ThinSlice<T>) -> Self {
+        let boxed: Box<[T]> = slice.slice.into();
+        boxed.into_vec()
+    }
+}
+
+impl<T> FromIterator<T> for ThinSlice<T> {
+    fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> Self {
+        let vec: Vec<T> = iter.into_iter().collect();
+        vec.into()
+    }
+}
+
+impl<T> Deref for ThinSlice<T> {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        self.slice.deref()
+    }
+}
+
+impl<T> DerefMut for ThinSlice<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.slice.deref_mut()
+    }
+}
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 6fdaa8b950aa1..fc18ab331f2ca 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1002,6 +1002,18 @@ impl<T, A: Allocator> Vec<T, A> {
         }
     }
 
+    /// WIP
+    #[cfg(not(no_global_oom_handling))]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    pub fn into_boxed_slice2(self) -> Box<[T], A> {
+        unsafe {
+            let me = ManuallyDrop::new(self);
+            let buf = ptr::read(&me.buf);
+            let len = me.len();
+            buf.into_box(len).assume_init()
+        }
+    }
+
     /// Shortens the vector, keeping the first `len` elements and dropping
     /// the rest.
     ///
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index 09692d27e8fbe..0f0bb61aa2f47 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -122,7 +122,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 generics: new_generics,
                 trait_: Some(trait_ref.clean(self.cx)),
                 for_: ty.clean(self.cx),
-                items: Vec::new(),
+                items: Default::default(),
                 polarity,
                 kind: ImplKind::Auto,
             }),
@@ -354,8 +354,9 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 if let Some(data) = ty_to_fn.get(&ty) {
                     let (poly_trait, output) =
                         (data.0.as_ref().unwrap().clone(), data.1.as_ref().cloned().map(Box::new));
-                    let mut new_path = poly_trait.trait_.clone();
-                    let last_segment = new_path.segments.pop().expect("segments were empty");
+                    let new_path = poly_trait.trait_.clone();
+                    let mut segments = new_path.segments.into_vec();
+                    let last_segment = segments.pop().expect("segments were empty");
 
                     let (old_input, old_output) = match last_segment.args {
                         GenericArgs::AngleBracketed { args, .. } => {
@@ -377,10 +378,10 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
 
                     let new_params = GenericArgs::Parenthesized { inputs: old_input, output };
 
-                    new_path
-                        .segments
+                    segments
                         .push(PathSegment { name: last_segment.name, args: new_params });
 
+                    let new_path = Path { segments: segments.into(), ..new_path };
                     bounds.insert(GenericBound::TraitBound(
                         PolyTrait { trait_: new_path, generic_params: poly_trait.generic_params },
                         hir::TraitBoundModifier::None,
@@ -396,7 +397,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 Some(WherePredicate::BoundPredicate {
                     ty,
                     bounds: bounds_vec,
-                    bound_params: Vec::new(),
+                    bound_params: Default::default(),
                 })
             })
             .chain(
@@ -404,7 +405,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                     |(lifetime, bounds)| {
                         let mut bounds_vec = bounds.into_iter().collect();
                         self.sort_where_bounds(&mut bounds_vec);
-                        WherePredicate::RegionPredicate { lifetime, bounds: bounds_vec }
+                        WherePredicate::RegionPredicate { lifetime, bounds: bounds_vec.into() }
                     },
                 ),
             )
@@ -520,7 +521,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                             GenericBound::TraitBound(ref mut p, _) => {
                                 // Insert regions into the for_generics hash map first, to ensure
                                 // that we don't end up with duplicate bounds (e.g., for<'b, 'b>)
-                                for_generics.extend(p.generic_params.clone());
+                                for_generics.extend(p.generic_params.clone().into_vec());
                                 p.generic_params = for_generics.into_iter().collect();
                                 self.is_fn_trait(&p.trait_)
                             }
@@ -542,7 +543,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                     }
                 }
                 WherePredicate::RegionPredicate { lifetime, bounds } => {
-                    lifetime_to_bounds.entry(lifetime).or_default().extend(bounds);
+                    lifetime_to_bounds.entry(lifetime).or_default().extend(bounds.into_vec());
                 }
                 WherePredicate::EqPredicate { lhs, rhs } => {
                     match lhs {
@@ -586,7 +587,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                             let bounds = ty_to_bounds.entry(*ty.clone()).or_default();
 
                             bounds.insert(GenericBound::TraitBound(
-                                PolyTrait { trait_: new_trait, generic_params: Vec::new() },
+                                PolyTrait { trait_: new_trait, generic_params: Default::default() },
                                 hir::TraitBoundModifier::None,
                             ));
 
@@ -595,7 +596,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                             // duplicate bound like `T: Iterator + Iterator<Item=u8>`
                             // on the docs page.
                             bounds.remove(&GenericBound::TraitBound(
-                                PolyTrait { trait_: trait_.clone(), generic_params: Vec::new() },
+                                PolyTrait { trait_: trait_.clone(), generic_params: Default::default() },
                                 hir::TraitBoundModifier::None,
                             ));
                             // Avoid creating any new duplicate bounds later in the outer
diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs
index f54ab9f2b11aa..a805ddc3efcfb 100644
--- a/src/librustdoc/clean/blanket_impl.rs
+++ b/src/librustdoc/clean/blanket_impl.rs
@@ -123,7 +123,7 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
                             .associated_items(impl_def_id)
                             .in_definition_order()
                             .map(|x| x.clean(self.cx))
-                            .collect::<Vec<_>>(),
+                            .collect(),
                         polarity: ty::ImplPolarity::Positive,
                         kind: ImplKind::Blanket(box trait_ref.self_ty().clean(self.cx)),
                     }),
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index ce0ac322af914..4ff87c5d25598 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -216,7 +216,7 @@ crate fn build_external_trait(cx: &mut DocContext<'_>, did: DefId) -> clean::Tra
         unsafety: cx.tcx.trait_def(did).unsafety,
         generics,
         items: trait_items,
-        bounds: supertrait_bounds,
+        bounds: supertrait_bounds.into(),
         is_auto,
     }
 }
@@ -496,7 +496,7 @@ crate fn build_impl(
             generics,
             trait_,
             for_,
-            items: trait_items,
+            items: trait_items.into(),
             polarity,
             kind: ImplKind::Normal,
         }),
@@ -540,10 +540,10 @@ 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(),
                                     },
-                                }],
+                                }].into(),
                             },
                             did: None,
                         },
@@ -604,7 +604,7 @@ fn build_macro(
         }
         LoadedMacro::ProcMacro(ext) => clean::ProcMacroItem(clean::ProcMacro {
             kind: ext.macro_kind(),
-            helpers: ext.helper_attrs,
+            helpers: ext.helper_attrs.into(),
         }),
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 959be5478b4ec..5f10b045d9ddb 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -13,6 +13,7 @@ use rustc_ast as ast;
 use rustc_attr as attr;
 use rustc_const_eval::const_eval::is_unstable_const_fn;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::thin_slice::ThinSlice;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
@@ -113,7 +114,7 @@ impl Clean<Option<GenericBound>> for hir::GenericBound<'_> {
 
                 let trait_ = clean_trait_ref_with_bindings(cx, trait_ref, &bindings);
                 GenericBound::TraitBound(
-                    PolyTrait { trait_, generic_params: vec![] },
+                    PolyTrait { trait_, generic_params: Default::default() },
                     hir::TraitBoundModifier::None,
                 )
             }
@@ -177,7 +178,7 @@ fn clean_poly_trait_ref_with_bindings(
 
     let trait_ = clean_trait_ref_with_bindings(cx, poly_trait_ref.skip_binder(), bindings);
     GenericBound::TraitBound(
-        PolyTrait { trait_, generic_params: late_bound_regions },
+        PolyTrait { trait_, generic_params: late_bound_regions.into() },
         hir::TraitBoundModifier::None,
     )
 }
@@ -314,7 +315,7 @@ impl<'a> Clean<Option<WherePredicate>> for ty::PolyTraitPredicate<'a> {
         Some(WherePredicate::BoundPredicate {
             ty: poly_trait_ref.skip_binder().self_ty().clean(cx),
             bounds: vec![poly_trait_ref.clean(cx)],
-            bound_params: Vec::new(),
+            bound_params: Default::default(),
         })
     }
 }
@@ -331,7 +332,7 @@ impl<'tcx> Clean<Option<WherePredicate>>
 
         Some(WherePredicate::RegionPredicate {
             lifetime: a.clean(cx).expect("failed to clean lifetime"),
-            bounds: vec![GenericBound::Outlives(b.clean(cx).expect("failed to clean bounds"))],
+            bounds: vec![GenericBound::Outlives(b.clean(cx).expect("failed to clean bounds"))].into(),
         })
     }
 }
@@ -347,7 +348,7 @@ impl<'tcx> Clean<Option<WherePredicate>> for ty::OutlivesPredicate<Ty<'tcx>, ty:
         Some(WherePredicate::BoundPredicate {
             ty: ty.clean(cx),
             bounds: vec![GenericBound::Outlives(lt.clean(cx).expect("failed to clean lifetimes"))],
-            bound_params: Vec::new(),
+            bound_params: Default::default(),
         })
     }
 }
@@ -691,7 +692,7 @@ fn clean_ty_generics(
             where_predicates.push(WherePredicate::BoundPredicate {
                 ty: Type::Generic(tp.name),
                 bounds: vec![GenericBound::maybe_sized(cx)],
-                bound_params: Vec::new(),
+                bound_params: Default::default(),
             })
         }
     }
@@ -750,7 +751,7 @@ fn clean_fn_or_proc_macro(
                     }
                 }
             }
-            ProcMacroItem(ProcMacro { kind, helpers })
+            ProcMacroItem(ProcMacro { kind, helpers: helpers.into() })
         }
         None => {
             let mut func = clean_function(cx, sig, generics, body_id);
@@ -1437,7 +1438,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                 let decl = clean_fn_decl_from_did_and_sig(cx, def_id, sig);
                 BareFunction(box BareFunctionDecl {
                     unsafety: sig.unsafety(),
-                    generic_params: Vec::new(),
+                    generic_params: Default::default(),
                     decl,
                     abi: sig.abi(),
                 })
@@ -1481,7 +1482,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                     let empty = cx.tcx.intern_substs(&[]);
                     let path = external_path(cx, did, false, vec![], empty);
                     inline::record_extern_fqn(cx, did, ItemType::Trait);
-                    let bound = PolyTrait { trait_: path, generic_params: Vec::new() };
+                    let bound = PolyTrait { trait_: path, generic_params: Default::default() };
                     bounds.push(bound);
                 }
 
@@ -1494,7 +1495,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
                 }
 
                 let path = external_path(cx, did, false, bindings, substs);
-                bounds.insert(0, PolyTrait { trait_: path, generic_params: Vec::new() });
+                bounds.insert(0, PolyTrait { trait_: path, generic_params: Default::default() });
 
                 DynTrait(bounds, lifetime)
             }
@@ -1663,8 +1664,8 @@ impl Clean<VariantStruct> for rustc_hir::VariantData<'_> {
     }
 }
 
-impl Clean<Vec<Item>> for hir::VariantData<'_> {
-    fn clean(&self, cx: &mut DocContext<'_>) -> Vec<Item> {
+impl Clean<ThinSlice<Item>> for hir::VariantData<'_> {
+    fn clean(&self, cx: &mut DocContext<'_>) -> ThinSlice<Item> {
         self.fields().iter().map(|x| x.clean(cx)).collect()
     }
 }
@@ -1876,7 +1877,7 @@ fn clean_impl(impl_: &hir::Impl<'_>, hir_id: hir::HirId, cx: &mut DocContext<'_>
             generics: impl_.generics.clean(cx),
             trait_,
             for_,
-            items,
+            items: items.into(),
             polarity: tcx.impl_polarity(def_id),
             kind: ImplKind::Normal,
         });
diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs
index 4c81e75e8d630..b5445043face9 100644
--- a/src/librustdoc/clean/simplify.rs
+++ b/src/librustdoc/clean/simplify.rs
@@ -37,7 +37,7 @@ crate fn where_clauses(cx: &DocContext<'_>, clauses: Vec<WP>) -> Vec<WP> {
                 clean::Generic(s) => {
                     let (b, p) = params.entry(s).or_default();
                     b.extend(bounds);
-                    p.extend(bound_params);
+                    p.extend(bound_params.into_vec());
                 }
                 t => tybounds.push((t, (bounds, bound_params))),
             },
@@ -76,7 +76,7 @@ crate fn where_clauses(cx: &DocContext<'_>, clauses: Vec<WP>) -> Vec<WP> {
     clauses.extend(params.into_iter().map(|(k, (bounds, params))| WP::BoundPredicate {
         ty: clean::Generic(k),
         bounds,
-        bound_params: params,
+        bound_params: params.into(),
     }));
     clauses.extend(tybounds.into_iter().map(|(ty, (bounds, bound_params))| WP::BoundPredicate {
         ty,
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 2ee5de24687f1..3c3f2e1267bda 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -16,6 +16,7 @@ use rustc_ast::{self as ast, AttrStyle};
 use rustc_attr::{ConstStability, Deprecation, Stability, StabilityLevel};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::thin_vec::ThinVec;
+use rustc_data_structures::thin_slice::ThinSlice;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
@@ -1163,7 +1164,7 @@ impl GenericBound {
         let path = external_path(cx, did, false, vec![], empty);
         inline::record_extern_fqn(cx, did, ItemType::Trait);
         GenericBound::TraitBound(
-            PolyTrait { trait_: path, generic_params: Vec::new() },
+            PolyTrait { trait_: path, generic_params: Default::default() },
             hir::TraitBoundModifier::Maybe,
         )
     }
@@ -1209,8 +1210,8 @@ impl Lifetime {
 
 #[derive(Clone, Debug)]
 crate enum WherePredicate {
-    BoundPredicate { ty: Type, bounds: Vec<GenericBound>, bound_params: Vec<Lifetime> },
-    RegionPredicate { lifetime: Lifetime, bounds: Vec<GenericBound> },
+    BoundPredicate { ty: Type, bounds: Vec<GenericBound>, bound_params: ThinSlice<Lifetime> },
+    RegionPredicate { lifetime: Lifetime, bounds: ThinSlice<GenericBound> },
     EqPredicate { lhs: Type, rhs: Type },
 }
 
@@ -1224,6 +1225,9 @@ impl WherePredicate {
     }
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(WherePredicate, 120);
+
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate enum GenericParamDefKind {
     Lifetime { outlives: Vec<Lifetime> },
@@ -1372,25 +1376,34 @@ impl FnRetTy {
 #[derive(Clone, Debug)]
 crate struct Trait {
     crate unsafety: hir::Unsafety,
-    crate items: Vec<Item>,
+    crate items: ThinSlice<Item>,
     crate generics: Generics,
-    crate bounds: Vec<GenericBound>,
+    crate bounds: ThinSlice<GenericBound>,
     crate is_auto: bool,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(Trait, 72);
+
 #[derive(Clone, Debug)]
 crate struct TraitAlias {
     crate generics: Generics,
-    crate bounds: Vec<GenericBound>,
+    crate bounds: ThinSlice<GenericBound>,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(TraitAlias, 56);
+
 /// A trait reference, which may have higher ranked lifetimes.
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate struct PolyTrait {
     crate trait_: Path,
-    crate generic_params: Vec<GenericParamDef>,
+    crate generic_params: ThinSlice<GenericParamDef>,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(PolyTrait, 40);
+
 /// Rustdoc's representation of types, mostly based on the [`hir::Ty`].
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate enum Type {
@@ -1440,7 +1453,7 @@ crate enum Type {
 
 // `Type` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Type, 72);
+rustc_data_structures::static_assert_size!(Type, 56);
 
 impl Type {
     /// When comparing types for equality, it can help to ignore `&` wrapping.
@@ -1905,27 +1918,36 @@ impl Visibility {
 crate struct Struct {
     crate struct_type: CtorKind,
     crate generics: Generics,
-    crate fields: Vec<Item>,
+    crate fields: ThinSlice<Item>,
     crate fields_stripped: bool,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(Struct, 64);
+
 #[derive(Clone, Debug)]
 crate struct Union {
     crate generics: Generics,
-    crate fields: Vec<Item>,
+    crate fields: ThinSlice<Item>,
     crate fields_stripped: bool,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(Union, 64);
+
 /// This is a more limited form of the standard Struct, different in that
 /// it lacks the things most items have (name, id, parameterization). Found
 /// only as a variant in an enum.
 #[derive(Clone, Debug)]
 crate struct VariantStruct {
     crate struct_type: CtorKind,
-    crate fields: Vec<Item>,
+    crate fields: ThinSlice<Item>,
     crate fields_stripped: bool,
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(VariantStruct, 16);
+
 #[derive(Clone, Debug)]
 crate struct Enum {
     crate variants: IndexVec<VariantIdx, Item>,
@@ -1936,10 +1958,13 @@ crate struct Enum {
 #[derive(Clone, Debug)]
 crate enum Variant {
     CLike,
-    Tuple(Vec<Item>),
+    Tuple(ThinSlice<Item>),
     Struct(VariantStruct),
 }
 
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(Variant, 24);
+
 /// Small wrapper around [`rustc_span::Span`] that adds helper methods
 /// and enforces calling [`rustc_span::Span::source_callsite()`].
 #[derive(Copy, Clone, Debug)]
@@ -1987,7 +2012,7 @@ impl Span {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate struct Path {
     crate res: Res,
-    crate segments: Vec<PathSegment>,
+    crate segments: ThinSlice<PathSegment>,
 }
 
 impl Path {
@@ -2056,18 +2081,18 @@ crate enum GenericArg {
 // `GenericArg` can occur many times in a single `Path`, so make sure it
 // doesn't increase in size unexpectedly.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(GenericArg, 80);
+rustc_data_structures::static_assert_size!(GenericArg, 64);
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate enum GenericArgs {
-    AngleBracketed { args: Vec<GenericArg>, bindings: ThinVec<TypeBinding> },
-    Parenthesized { inputs: Vec<Type>, output: Option<Box<Type>> },
+    AngleBracketed { args: ThinSlice<GenericArg>, bindings: ThinVec<TypeBinding> },
+    Parenthesized { inputs: ThinSlice<Type>, output: Option<Box<Type>> },
 }
 
 // `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, 24);
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate struct PathSegment {
@@ -2078,7 +2103,7 @@ 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, 32);
 
 #[derive(Clone, Debug)]
 crate struct Typedef {
@@ -2095,14 +2120,14 @@ crate struct Typedef {
 
 #[derive(Clone, Debug)]
 crate struct OpaqueTy {
-    crate bounds: Vec<GenericBound>,
+    crate bounds: ThinSlice<GenericBound>,
     crate generics: Generics,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate struct BareFunctionDecl {
     crate unsafety: hir::Unsafety,
-    crate generic_params: Vec<GenericParamDef>,
+    crate generic_params: ThinSlice<GenericParamDef>,
     crate decl: FnDecl,
     crate abi: Abi,
 }
@@ -2191,7 +2216,7 @@ crate struct Impl {
     crate generics: Generics,
     crate trait_: Option<Path>,
     crate for_: Type,
-    crate items: Vec<Item>,
+    crate items: ThinSlice<Item>,
     crate polarity: ty::ImplPolarity,
     crate kind: ImplKind,
 }
@@ -2269,7 +2294,7 @@ crate struct Macro {
 #[derive(Clone, Debug)]
 crate struct ProcMacro {
     crate kind: MacroKind,
-    crate helpers: Vec<Symbol>,
+    crate helpers: ThinSlice<Symbol>,
 }
 
 /// An type binding on an associated type (e.g., `A = Bar` in `Foo<A = Bar>` or
@@ -2283,7 +2308,7 @@ crate struct TypeBinding {
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate enum TypeBindingKind {
     Equality { ty: Type },
-    Constraint { bounds: Vec<GenericBound> },
+    Constraint { bounds: ThinSlice<GenericBound> },
 }
 
 impl TypeBinding {
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index 43dcb611a377d..14a9d4b38bad7 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -109,7 +109,7 @@ fn external_generic_args(
     if cx.tcx.fn_trait_kind_from_lang_item(did).is_some() {
         let inputs = match ty_kind.unwrap() {
             ty::Tuple(tys) => tys.iter().map(|t| t.expect_ty().clean(cx)).collect(),
-            _ => return GenericArgs::AngleBracketed { args, bindings: bindings.into() },
+            _ => return GenericArgs::AngleBracketed { args: args.into(), bindings: bindings.into() },
         };
         let output = None;
         // FIXME(#20299) return type comes from a projection now
@@ -119,7 +119,7 @@ fn external_generic_args(
         // };
         GenericArgs::Parenthesized { inputs, output }
     } else {
-        GenericArgs::AngleBracketed { args, bindings: bindings.into() }
+        GenericArgs::AngleBracketed { args: args.into(), bindings: bindings.into() }
     }
 }
 
@@ -137,14 +137,14 @@ pub(super) fn external_path(
         segments: vec![PathSegment {
             name,
             args: external_generic_args(cx, did, has_self, bindings, substs),
-        }],
+        }].into(),
     }
 }
 
 /// Remove the generic arguments from a path.
 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/fold.rs b/src/librustdoc/fold.rs
index cd0f44e5696fe..92e47744dff3a 100644
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -1,4 +1,5 @@
 use crate::clean::*;
+use rustc_data_structures::thin_slice::ThinSlice;
 
 crate fn strip_item(mut item: Item) -> Item {
     if !matches!(*item.kind, StrippedItem(..)) {
@@ -19,7 +20,7 @@ crate trait DocFolder: Sized {
             ModuleItem(i) => ModuleItem(self.fold_mod(i)),
             StructItem(mut i) => {
                 let num_fields = i.fields.len();
-                i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                i.fields = i.fields.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                 if !i.fields_stripped {
                     i.fields_stripped =
                         num_fields != i.fields.len() || i.fields.iter().any(|f| f.is_stripped());
@@ -28,7 +29,7 @@ crate trait DocFolder: Sized {
             }
             UnionItem(mut i) => {
                 let num_fields = i.fields.len();
-                i.fields = i.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                i.fields = i.fields.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                 if !i.fields_stripped {
                     i.fields_stripped =
                         num_fields != i.fields.len() || i.fields.iter().any(|f| f.is_stripped());
@@ -45,17 +46,17 @@ crate trait DocFolder: Sized {
                 EnumItem(i)
             }
             TraitItem(mut i) => {
-                i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                i.items = i.items.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                 TraitItem(i)
             }
             ImplItem(mut i) => {
-                i.items = i.items.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                i.items = i.items.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                 ImplItem(i)
             }
             VariantItem(i) => match i {
                 Variant::Struct(mut j) => {
                     let num_fields = j.fields.len();
-                    j.fields = j.fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                    j.fields = j.fields.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                     if !j.fields_stripped {
                         j.fields_stripped = num_fields != j.fields.len()
                             || j.fields.iter().any(|f| f.is_stripped());
@@ -63,7 +64,7 @@ crate trait DocFolder: Sized {
                     VariantItem(Variant::Struct(j))
                 }
                 Variant::Tuple(fields) => {
-                    let fields = fields.into_iter().filter_map(|x| self.fold_item(x)).collect();
+                    let fields: ThinSlice<_> = fields.into_vec().into_iter().filter_map(|x| self.fold_item(x)).collect();
                     VariantItem(Variant::Tuple(fields))
                 }
                 Variant::CLike => VariantItem(Variant::CLike),
@@ -112,7 +113,7 @@ crate trait DocFolder: Sized {
 
         let external_traits = { std::mem::take(&mut *c.external_traits.borrow_mut()) };
         for (k, mut v) in external_traits {
-            v.trait_.items = v.trait_.items.into_iter().filter_map(|i| self.fold_item(i)).collect();
+            v.trait_.items = v.trait_.items.into_vec().into_iter().filter_map(|i| self.fold_item(i)).collect();
             c.external_traits.borrow_mut().insert(k, v);
         }
 
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 981eb9589e9f1..9a46b177500c7 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -432,7 +432,7 @@ impl clean::GenericArgs {
                             f.write_str("&lt;")?;
                         }
                         let mut comma = false;
-                        for arg in args {
+                        for arg in args.iter() {
                             if comma {
                                 f.write_str(", ")?;
                             }
@@ -464,7 +464,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/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 16334890da674..659375f80f1cd 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1266,7 +1266,7 @@ fn notable_traits_decl(decl: &clean::FnDecl, cx: &Context<'_>) -> String {
                             "<span class=\"where fmt-newline\">{}</span>",
                             impl_.print(false, cx)
                         );
-                        for it in &impl_.items {
+                        for it in impl_.items.iter() {
                             if let clean::TypedefItem(ref tydef, _) = *it.kind {
                                 out.push_str("<span class=\"where fmt-newline\">    ");
                                 let empty_set = FxHashSet::default();
@@ -1515,7 +1515,7 @@ fn render_impl(
     let mut impl_items = Buffer::empty_from(w);
     let mut default_impl_items = Buffer::empty_from(w);
 
-    for trait_item in &i.inner_impl().items {
+    for trait_item in i.inner_impl().items.iter() {
         doc_impl_item(
             &mut default_impl_items,
             &mut impl_items,
@@ -1542,7 +1542,7 @@ fn render_impl(
         render_mode: RenderMode,
         rendering_params: ImplRenderingParameters,
     ) {
-        for trait_item in &t.items {
+        for trait_item in t.items.iter() {
             let n = trait_item.name;
             if i.items.iter().any(|m| m.name == n) {
                 continue;
@@ -1706,7 +1706,7 @@ pub(crate) fn render_impl_summary(
     if let Some(use_absolute) = use_absolute {
         write!(w, "{}", i.inner_impl().print(use_absolute, cx));
         if show_def_docs {
-            for it in &i.inner_impl().items {
+            for it in i.inner_impl().items.iter() {
                 if let clean::TypedefItem(ref tydef, _) = *it.kind {
                     w.write_str("<span class=\"where fmt-newline\">  ");
                     assoc_type(w, it, &[], Some(&tydef.type_), AssocItemLink::Anchor(None), "", cx);
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 44a9ec5ea4210..c2f7eaf28874b 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1146,7 +1146,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
                 write!(w, "<div class=\"sub-variant\" id=\"{id}\">", id = variant_id);
                 write!(w, "<h4>{extra}Fields</h4>", extra = extra,);
                 document_non_exhaustive(w, variant);
-                for field in fields {
+                for field in fields.iter() {
                     match *field.kind {
                         clean::StrippedItem(box clean::StructFieldItem(_)) => {}
                         clean::StructFieldItem(ref ty) => {
@@ -1220,7 +1220,7 @@ fn item_proc_macro(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, m: &clean
                     if !m.helpers.is_empty() {
                         w.push_str("\n{\n");
                         w.push_str("    // Attributes available to this derive:\n");
-                        for attr in &m.helpers {
+                        for attr in m.helpers.iter() {
                             writeln!(w, "    #[{}]", attr);
                         }
                         w.push_str("}\n");
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index c8efa4bbbcc30..e414a9b6c5ff3 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -120,11 +120,11 @@ impl FromWithTcx<clean::GenericArgs> 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)),
             },
         }
@@ -164,7 +164,7 @@ impl FromWithTcx<clean::TypeBindingKind> for TypeBindingKind {
         match kind {
             Equality { ty } => TypeBindingKind::Equality(ty.into_tcx(tcx)),
             Constraint { bounds } => {
-                TypeBindingKind::Constraint(bounds.into_iter().map(|a| a.into_tcx(tcx)).collect())
+                TypeBindingKind::Constraint(bounds.into_vec().into_iter().map(|a| a.into_tcx(tcx)).collect())
             }
         }
     }
@@ -245,7 +245,7 @@ impl FromWithTcx<clean::Struct> for Struct {
             struct_type: from_ctor_kind(struct_type),
             generics: generics.into_tcx(tcx),
             fields_stripped,
-            fields: ids(fields),
+            fields: ids(fields.into_vec()),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -257,7 +257,7 @@ impl FromWithTcx<clean::Union> for Union {
         Union {
             generics: generics.into_tcx(tcx),
             fields_stripped,
-            fields: ids(fields),
+            fields: ids(fields.into_vec()),
             impls: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -352,7 +352,7 @@ impl FromWithTcx<clean::WherePredicate> for WherePredicate {
             },
             RegionPredicate { lifetime, bounds } => WherePredicate::RegionPredicate {
                 lifetime: lifetime.0.to_string(),
-                bounds: bounds.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+                bounds: bounds.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
             },
             EqPredicate { lhs, rhs } => {
                 WherePredicate::EqPredicate { lhs: lhs.into_tcx(tcx), rhs: rhs.into_tcx(tcx) }
@@ -370,7 +370,7 @@ impl FromWithTcx<clean::GenericBound> for GenericBound {
                 let trait_ = clean::Type::Path { path: trait_ }.into_tcx(tcx);
                 GenericBound::TraitBound {
                     trait_,
-                    generic_params: generic_params.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+                    generic_params: generic_params.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
                     modifier: from_trait_bound_modifier(modifier),
                 }
             }
@@ -463,7 +463,7 @@ impl FromWithTcx<clean::BareFunctionDecl> for FunctionPointer {
             } else {
                 HashSet::new()
             },
-            generic_params: generic_params.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+            generic_params: generic_params.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
             decl: decl.into_tcx(tcx),
             abi: abi.to_string(),
         }
@@ -494,9 +494,9 @@ impl FromWithTcx<clean::Trait> for Trait {
         Trait {
             is_auto,
             is_unsafe: unsafety == rustc_hir::Unsafety::Unsafe,
-            items: ids(items),
+            items: ids(items.into_vec()),
             generics: generics.into_tcx(tcx),
-            bounds: bounds.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+            bounds: bounds.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
             implementors: Vec::new(), // Added in JsonRenderer::item
         }
     }
@@ -527,7 +527,7 @@ impl FromWithTcx<clean::Impl> for Impl {
                 .collect(),
             trait_,
             for_: for_.into_tcx(tcx),
-            items: ids(items),
+            items: ids(items.into_vec()),
             negative: negative_polarity,
             synthetic,
             blanket_impl: blanket_impl.map(|x| x.into_tcx(tcx)),
@@ -569,7 +569,7 @@ impl FromWithTcx<clean::VariantStruct> for Struct {
             struct_type: from_ctor_kind(struct_type),
             generics: Default::default(),
             fields_stripped,
-            fields: ids(fields),
+            fields: ids(fields.into_vec()),
             impls: Vec::new(),
         }
     }
@@ -582,6 +582,7 @@ impl FromWithTcx<clean::Variant> for Variant {
             CLike => Variant::Plain,
             Tuple(fields) => Variant::Tuple(
                 fields
+                    .into_vec()
                     .into_iter()
                     .map(|f| {
                         if let clean::StructFieldItem(ty) = *f.kind {
@@ -592,7 +593,7 @@ impl FromWithTcx<clean::Variant> for Variant {
                     })
                     .collect(),
             ),
-            Struct(s) => Variant::Struct(ids(s.fields)),
+            Struct(s) => Variant::Struct(ids(s.fields.into_vec())),
         }
     }
 }
@@ -645,7 +646,7 @@ impl FromWithTcx<clean::Typedef> for Typedef {
 impl FromWithTcx<clean::OpaqueTy> for OpaqueTy {
     fn from_tcx(opaque: clean::OpaqueTy, tcx: TyCtxt<'_>) -> Self {
         OpaqueTy {
-            bounds: opaque.bounds.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+            bounds: opaque.bounds.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
             generics: opaque.generics.into_tcx(tcx),
         }
     }
@@ -665,7 +666,7 @@ impl FromWithTcx<clean::TraitAlias> for TraitAlias {
     fn from_tcx(alias: clean::TraitAlias, tcx: TyCtxt<'_>) -> Self {
         TraitAlias {
             generics: alias.generics.into_tcx(tcx),
-            params: alias.bounds.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+            params: alias.bounds.into_vec().into_iter().map(|x| x.into_tcx(tcx)).collect(),
         }
     }
 }
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index 88a5c0c5ca260..8eafb6006807e 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -102,7 +102,7 @@ impl<'tcx> JsonRenderer<'tcx> {
                 // only need to synthesize items for external traits
                 if !id.is_local() {
                     let trait_item = &trait_item.trait_;
-                    trait_item.items.clone().into_iter().for_each(|i| self.item(i).unwrap());
+                    trait_item.items.clone().into_vec().into_iter().for_each(|i| self.item(i).unwrap());
                     Some((
                         from_item_id(id.into()),
                         types::Item {