diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index bd5ce5d18b839..0a462379dcf7a 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -101,7 +101,7 @@ pub struct Path {
 }
 
 // Succeeds if the path has a single segment that is arg-free and matches the given symbol.
-impl PartialEq<Symbol> for Path {
+impl PartialEq<Symbol> for Box<Path> {
     #[inline]
     fn eq(&self, name: &Symbol) -> bool {
         if let [segment] = self.segments.as_ref()
@@ -115,7 +115,7 @@ impl PartialEq<Symbol> for Path {
 }
 
 // Succeeds if the path has segments that are arg-free and match the given symbols.
-impl PartialEq<&[Symbol]> for Path {
+impl PartialEq<&[Symbol]> for Box<Path> {
     #[inline]
     fn eq(&self, names: &&[Symbol]) -> bool {
         self.segments.iter().eq(*names)
@@ -134,8 +134,12 @@ impl StableHash for Path {
 impl Path {
     /// Convert a span and an identifier to the corresponding
     /// one-segment path.
-    pub fn from_ident(ident: Ident) -> Path {
-        Path { segments: thin_vec![PathSegment::from_ident(ident)], span: ident.span, tokens: None }
+    pub fn from_ident(ident: Ident) -> Box<Path> {
+        Box::new(Path {
+            segments: thin_vec![PathSegment::from_ident(ident)],
+            span: ident.span,
+            tokens: None,
+        })
     }
 
     pub fn is_global(&self) -> bool {
@@ -407,7 +411,7 @@ impl GenericBound {
     }
 }
 
-pub type GenericBounds = Vec<GenericBound>;
+pub type GenericBounds = ThinVec<GenericBound>;
 
 /// Specifies the enforced ordering for generic parameters. In the future,
 /// if we wanted to relax this order, we could override `PartialEq` and
@@ -567,7 +571,7 @@ pub struct Crate {
 #[derive(Clone, Encodable, Decodable, Debug, StableHash)]
 pub struct MetaItem {
     pub unsafety: Safety,
-    pub path: Path,
+    pub path: Box<Path>,
     pub kind: MetaItemKind,
     pub span: Span,
 }
@@ -884,10 +888,10 @@ pub enum PatKind {
     Ident(BindingMode, Ident, Option<Box<Pat>>),
 
     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
-    Struct(Option<Box<QSelf>>, Path, ThinVec<PatField>, PatFieldsRest),
+    Struct(Option<Box<QSelf>>, Box<Path>, ThinVec<PatField>, PatFieldsRest),
 
     /// A tuple struct/variant pattern (`Variant(x, y, .., z)`).
-    TupleStruct(Option<Box<QSelf>>, Path, ThinVec<Pat>),
+    TupleStruct(Option<Box<QSelf>>, Box<Path>, ThinVec<Pat>),
 
     /// An or-pattern `A | B | C`.
     /// Invariant: `pats.len() >= 2`.
@@ -897,7 +901,7 @@ pub enum PatKind {
     /// Unqualified path patterns `A::B::C` can legally refer to variants, structs, constants
     /// or associated constants. Qualified path patterns `<A>::B::C`/`<A as Trait>::B::C` can
     /// only legally refer to associated constants.
-    Path(Option<Box<QSelf>>, Path),
+    Path(Option<Box<QSelf>>, Box<Path>),
 
     /// A tuple pattern (`(a, b)`).
     Tuple(ThinVec<Pat>),
@@ -1534,7 +1538,7 @@ impl Expr {
                 let (Some(lhs), Some(rhs)) = (lhs.to_bound(), rhs.to_bound()) else {
                     return None;
                 };
-                TyKind::TraitObject(vec![lhs, rhs], TraitObjectSyntax::None)
+                TyKind::TraitObject(thin_vec![lhs, rhs], TraitObjectSyntax::None)
             }
 
             ExprKind::Underscore => TyKind::Infer,
@@ -1667,6 +1671,15 @@ impl From<Box<Expr>> for Expr {
     }
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub struct ForLoop {
+    pub pat: Box<Pat>,
+    pub iter: Box<Expr>,
+    pub body: Box<Block>,
+    pub label: Option<Label>,
+    pub kind: ForLoopKind,
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct Closure {
     pub binder: ClosureBinder,
@@ -1733,7 +1746,7 @@ pub enum StructRest {
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct StructExpr {
     pub qself: Option<Box<QSelf>>,
-    pub path: Path,
+    pub path: Box<Path>,
     pub fields: ThinVec<ExprField>,
     pub rest: StructRest,
 }
@@ -1792,13 +1805,7 @@ pub enum ExprKind {
     /// `'label: for await? pat in iter { block }`
     ///
     /// This is desugared to a combination of `loop` and `match` expressions.
-    ForLoop {
-        pat: Box<Pat>,
-        iter: Box<Expr>,
-        body: Box<Block>,
-        label: Option<Label>,
-        kind: ForLoopKind,
-    },
+    ForLoop(Box<ForLoop>),
     /// Conditionless loop (can be exited with `break`, `continue`, or `return`).
     ///
     /// `'label: loop { block }`
@@ -1850,7 +1857,7 @@ pub enum ExprKind {
     /// parameters (e.g., `foo::bar::<baz>`).
     ///
     /// Optionally "qualified" (e.g., `<Vec<T> as SomeTrait>::SomeType`).
-    Path(Option<Box<QSelf>>, Path),
+    Path(Option<Box<QSelf>>, Box<Path>),
 
     /// A referencing operation (`&a`, `&mut a`, `&raw const a` or `&raw mut a`).
     AddrOf(BorrowKind, Mutability, Box<Expr>),
@@ -1868,9 +1875,10 @@ pub enum ExprKind {
     ///
     /// Usually not written directly in user code but
     /// indirectly via the macro `core::mem::offset_of!(...)`.
-    OffsetOf(Box<Ty>, Vec<Ident>),
+    OffsetOf(Box<Ty>, ThinVec<Ident>),
 
     /// A macro invocation; pre-expansion.
+    // njn: debox all Box<MacCall>?
     MacCall(Box<MacCall>),
 
     /// A struct literal expression.
@@ -2043,7 +2051,7 @@ pub enum ClosureBinder {
 /// is being invoked, and the `args` are arguments passed to it.
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct MacCall {
-    pub path: Path,
+    pub path: Box<Path>,
     pub args: Box<DelimArgs>,
 }
 
@@ -2122,7 +2130,7 @@ pub struct MacroDef {
 #[derive(Clone, Encodable, Decodable, Debug, StableHash, Walkable)]
 pub struct EiiDecl {
     /// path to the extern item we're targeting
-    pub foreign_item: Path,
+    pub foreign_item: Box<Path>,
     pub impl_unsafe: bool,
 }
 
@@ -2534,7 +2542,7 @@ pub enum TyKind {
     /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
     ///
     /// Type parameters are stored in the `Path` itself.
-    Path(Option<Box<QSelf>>, Path),
+    Path(Option<Box<QSelf>>, Box<Path>),
     /// A trait object type `Bound1 + Bound2 + Bound3`
     /// where `Bound` is a trait or a lifetime.
     TraitObject(#[visitable(extra = BoundKind::TraitObject)] GenericBounds, TraitObjectSyntax),
@@ -2683,7 +2691,7 @@ pub enum PreciseCapturingArg {
     /// Lifetime parameter.
     Lifetime(#[visitable(extra = LifetimeCtxt::GenericArg)] Lifetime),
     /// Type or const parameter.
-    Arg(Path, NodeId),
+    Arg(Box<Path>, NodeId),
 }
 
 /// Inline assembly operand explicit register or register class.
@@ -2810,7 +2818,7 @@ impl InlineAsmTemplatePiece {
 pub struct InlineAsmSym {
     pub id: NodeId,
     pub qself: Option<Box<QSelf>>,
-    pub path: Path,
+    pub path: Box<Path>,
 }
 
 /// Inline assembly operand.
@@ -3366,7 +3374,7 @@ pub enum UseTreeKind {
 /// Used in `use` items both at top-level and inside of braces in import groups.
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct UseTree {
-    pub prefix: Path,
+    pub prefix: Box<Path>,
     pub kind: UseTreeKind,
 }
 
@@ -3464,7 +3472,7 @@ impl NormalAttr {
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct AttrItem {
     pub unsafety: Safety,
-    pub path: Path,
+    pub path: Box<Path>,
     pub args: AttrItemKind,
     // Tokens for the meta item, e.g. just the `foo` within `#[foo]` or `#![foo]`.
     pub tokens: Option<LazyAttrTokenStream>,
@@ -3532,7 +3540,7 @@ impl AttrItem {
 /// same as the impl's `NodeId`).
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct TraitRef {
-    pub path: Path,
+    pub path: Box<Path>,
     pub ref_id: NodeId,
 }
 
@@ -3564,7 +3572,7 @@ pub struct PolyTraitRef {
 impl PolyTraitRef {
     pub fn new(
         generic_params: ThinVec<GenericParam>,
-        path: Path,
+        path: Box<Path>,
         modifiers: TraitBoundModifiers,
         span: Span,
         parens: Parens,
@@ -3886,7 +3894,7 @@ pub struct Fn {
     pub generics: Generics,
     pub sig: FnSig,
     pub contract: Option<Box<FnContract>>,
-    pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
+    pub define_opaque: Option<ThinVec<(NodeId, Box<Path>)>>,
     pub body: Option<Box<Block>>,
 
     /// This function is an implementation of an externally implementable item (EII).
@@ -3911,7 +3919,7 @@ impl Fn {
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct EiiImpl {
     pub node_id: NodeId,
-    pub eii_macro_path: Path,
+    pub eii_macro_path: Box<Path>,
     /// This field is an implementation detail that prevents a lot of bugs.
     /// See <https://github.com/rust-lang/rust/issues/149981> for an example.
     ///
@@ -3943,7 +3951,7 @@ pub struct Delegation {
     /// Path resolution id.
     pub id: NodeId,
     pub qself: Option<Box<QSelf>>,
-    pub path: Path,
+    pub path: Box<Path>,
     pub ident: Ident,
     pub rename: Option<Ident>,
     pub body: Option<Box<Block>>,
@@ -3967,7 +3975,7 @@ pub enum DelegationSuffixes {
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct DelegationMac {
     pub qself: Option<Box<QSelf>>,
-    pub prefix: Path,
+    pub prefix: Box<Path>,
     pub suffixes: DelegationSuffixes,
     pub body: Option<Box<Block>>,
 }
@@ -3979,7 +3987,7 @@ pub struct StaticItem {
     pub safety: Safety,
     pub mutability: Mutability,
     pub expr: Option<Box<Expr>>,
-    pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
+    pub define_opaque: Option<ThinVec<(NodeId, Box<Path>)>>,
 
     /// This static is an implementation of an externally implementable item (EII).
     /// This means, there was an EII declared somewhere and this static is the
@@ -3996,7 +4004,7 @@ pub struct ConstItem {
     pub generics: Generics,
     pub ty: Box<Ty>,
     pub rhs_kind: ConstItemRhsKind,
-    pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
+    pub define_opaque: Option<ThinVec<(NodeId, Box<Path>)>>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
@@ -4391,30 +4399,40 @@ mod size_asserts {
     // tidy-alphabetical-start
     static_assert_size!(AssocItem, 80);
     static_assert_size!(AssocItemKind, 16);
+    static_assert_size!(AttrKind, 16);
     static_assert_size!(Attribute, 32);
     static_assert_size!(Block, 32);
-    static_assert_size!(Expr, 72);
-    static_assert_size!(ExprKind, 40);
+    static_assert_size!(Expr, 64);
+    static_assert_size!(ExprKind, 32);
     static_assert_size!(Fn, 192);
+    static_assert_size!(FnDecl, 24);
+    static_assert_size!(FnHeader, 76);
+    static_assert_size!(FnSig, 96);
     static_assert_size!(ForeignItem, 80);
     static_assert_size!(ForeignItemKind, 16);
     static_assert_size!(GenericArg, 24);
-    static_assert_size!(GenericBound, 88);
+    static_assert_size!(GenericArgs, 40);
+    static_assert_size!(GenericBound, 72);
+    static_assert_size!(GenericParam, 80);
     static_assert_size!(Generics, 40);
     static_assert_size!(Impl, 80);
     static_assert_size!(Item, 152);
     static_assert_size!(ItemKind, 88);
+    static_assert_size!(Lifetime, 16);
     static_assert_size!(LitKind, 24);
     static_assert_size!(Local, 96);
+    static_assert_size!(MetaItem, 72);
+    static_assert_size!(MetaItemKind, 40);
     static_assert_size!(MetaItemLit, 40);
     static_assert_size!(Param, 40);
-    static_assert_size!(Pat, 80);
-    static_assert_size!(PatKind, 56);
+    static_assert_size!(Pat, 64);
+    static_assert_size!(PatKind, 40);
     static_assert_size!(Path, 24);
     static_assert_size!(PathSegment, 24);
+    static_assert_size!(QSelf, 24);
     static_assert_size!(Stmt, 32);
     static_assert_size!(StmtKind, 16);
-    static_assert_size!(TraitImplHeader, 72);
+    static_assert_size!(TraitImplHeader, 56);
     static_assert_size!(Ty, 64);
     static_assert_size!(TyKind, 40);
     // tidy-alphabetical-end
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 88556aa58c773..e9d1c8e2f4d2b 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -515,7 +515,7 @@ impl MetaItem {
                     iter.next();
                 }
                 let span = span.with_hi(segments.last().unwrap().ident.span.hi());
-                Path { span, segments, tokens: None }
+                Box::new(Path { span, segments, tokens: None })
             }
             Some(TokenTree::Delimited(
                 _span,
@@ -741,7 +741,7 @@ fn mk_attr(
     g: &AttrIdGenerator,
     style: AttrStyle,
     unsafety: Safety,
-    path: Path,
+    path: Box<Path>,
     args: AttrArgs,
     span: Span,
 ) -> Attribute {
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index 0c98b0e5e7b4f..5d6176c6e4c0a 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/compiler/rustc_ast/src/util/classify.rs
@@ -101,7 +101,10 @@ pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
 pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
     loop {
         match &expr.kind {
-            Block(_, label) | ForLoop { label, .. } | Loop(_, label, _) | While(_, _, label) => {
+            Block(_, label)
+            | ForLoop(ast::ForLoop { label, .. })
+            | Loop(_, label, _)
+            | While(_, _, label) => {
                 return label.is_some();
             }
 
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index 1e96d1d52f7eb..ce3f923f8d174 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -386,8 +386,10 @@ macro_rules! common_visitor_and_walkers {
         impl_visitable_list!(<$($lt)? $($mut)?>
             ThinVec<AngleBracketedArg>,
             ThinVec<Attribute>,
+            ThinVec<GenericBound>,
+            ThinVec<Ident>,
             ThinVec<(Ident, Option<Ident>)>,
-            ThinVec<(NodeId, Path)>,
+            ThinVec<(NodeId, Box<Path>)>,
             ThinVec<PathSegment>,
             ThinVec<PreciseCapturingArg>,
             ThinVec<Pat>,
@@ -999,7 +1001,7 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!($($mut)? vis, head_expression, if_block, optional_else),
                 ExprKind::While(subexpression, block, opt_label) =>
                     visit_visitable!($($mut)? vis, subexpression, block, opt_label),
-                ExprKind::ForLoop { pat, iter, body, label, kind } =>
+                ExprKind::ForLoop(ForLoop { pat, iter, body, label, kind }) =>
                     visit_visitable!($($mut)? vis, pat, iter, body, label, kind),
                 ExprKind::Loop(block, opt_label, span) =>
                     visit_visitable!($($mut)? vis, block, opt_label, span),
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index f66d1ac16c907..d9119dac24a8f 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -191,7 +191,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 //
                 // This also needs special handling because the HirId of the returned `hir::Expr` will not
                 // correspond to the `e.id`, so `lower_expr_for` handles attribute lowering itself.
-                ExprKind::ForLoop { pat, iter, body, label, kind } => {
+                ExprKind::ForLoop(ForLoop { pat, iter, body, label, kind }) => {
                     return self.lower_expr_for(e, pat, iter, body, *label, *kind);
                 }
                 ExprKind::Closure(closure) => return self.lower_expr_closure_expr(e, closure),
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index c54777d98070a..3c8e63f9652eb 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1902,7 +1902,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_define_opaque(
         &mut self,
         hir_id: HirId,
-        define_opaque: &Option<ThinVec<(NodeId, Path)>>,
+        define_opaque: &Option<ThinVec<(NodeId, Box<Path>)>>,
     ) {
         assert_eq!(self.define_opaque, None);
         assert!(hir_id.is_owner());
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 35e16ce78a8a8..c669f645f7bad 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -516,7 +516,7 @@ fn index_ast<'tcx>(
                 // Lacking a better choice, we replace the contents with a macro call.
                 // Unexpanded macros should never reach lowering, so this is not confusing.
                 kind: dummy(Box::new(MacCall {
-                    path: Path { span, segments: thin_vec![], tokens: None },
+                    path: Box::new(Path { span, segments: thin_vec![], tokens: None }),
                     args: Box::new(DelimArgs {
                         dspan: DelimSpan::from_single(span),
                         delim: Delimiter::Parenthesis,
@@ -1462,7 +1462,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         t: &Ty,
         qself: &Option<Box<QSelf>>,
-        path: &Path,
+        path: &Box<Path>,
         param_mode: ParamMode,
         itctx: ImplTraitContext,
     ) -> hir::Ty<'hir> {
@@ -2541,7 +2541,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     #[instrument(level = "debug", skip(self))]
     fn lower_const_path_to_const_arg(
         &mut self,
-        path: &Path,
+        path: &Box<Path>,
         res: Res<NodeId>,
         ty_id: NodeId,
         span: Span,
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 176e91e544ec5..de7e4f3112f5b 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -526,7 +526,7 @@ impl<'a> State<'a> {
                 self.space();
                 self.print_block_with_attrs(blk, attrs, cb, ib);
             }
-            ast::ExprKind::ForLoop { pat, iter, body, label, kind } => {
+            ast::ExprKind::ForLoop(ast::ForLoop { pat, iter, body, label, kind }) => {
                 if let Some(label) = label {
                     self.print_ident(label.ident);
                     self.word_space(":");
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
index 8602a21a43487..d6b35e63da87c 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/item.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -94,7 +94,7 @@ impl<'a> State<'a> {
         vis: &ast::Visibility,
         safety: ast::Safety,
         defaultness: ast::Defaultness,
-        define_opaque: Option<&[(ast::NodeId, ast::Path)]>,
+        define_opaque: Option<&[(ast::NodeId, Box<ast::Path>)]>,
         eii_impls: &[EiiImpl],
     ) {
         self.print_define_opaques(define_opaque);
@@ -777,7 +777,7 @@ impl<'a> State<'a> {
         self.hardbreak();
     }
 
-    fn print_define_opaques(&mut self, define_opaque: Option<&[(ast::NodeId, ast::Path)]>) {
+    fn print_define_opaques(&mut self, define_opaque: Option<&[(ast::NodeId, Box<ast::Path>)]>) {
         if let Some(define_opaque) = define_opaque {
             self.word("#[define_opaque(");
             for (i, (_, path)) in define_opaque.iter().enumerate() {
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
index 5450a51484542..ef05743639c85 100644
--- a/compiler/rustc_attr_parsing/src/parser.rs
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -37,7 +37,7 @@ use crate::session_diagnostics::{
 #[derive(Clone, Debug)]
 pub struct PathParser<P: Borrow<Path>>(pub P);
 
-pub type OwnedPathParser = PathParser<Path>;
+pub type OwnedPathParser = PathParser<Box<Path>>;
 pub type RefPathParser<'p> = PathParser<&'p Path>;
 
 impl<P: Borrow<Path>> PathParser<P> {
@@ -678,7 +678,8 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
                         negative_sign: expr.span.until(val.span),
                     });
                 } else if let StmtKind::Expr(expr) = &stmt.kind
-                    && let ExprKind::Path(None, Path { segments, .. }) = &expr.kind
+                    && let ExprKind::Path(None, path) = &expr.kind
+                    && let Path { segments, .. } = &**path
                     && segments.len() == 1
                 {
                     while let token::Ident(..) | token::Literal(_) | token::Dot =
diff --git a/compiler/rustc_builtin_macros/src/assert.rs b/compiler/rustc_builtin_macros/src/assert.rs
index 444510ee50572..9103b8409b5c4 100644
--- a/compiler/rustc_builtin_macros/src/assert.rs
+++ b/compiler/rustc_builtin_macros/src/assert.rs
@@ -34,7 +34,7 @@ pub(crate) fn expand_assert<'cx>(
     let panic_path = || {
         if use_panic_2021(span) {
             // On edition 2021, we always call `$crate::panic::panic_2021!()`.
-            Path {
+            Box::new(Path {
                 span: call_site_span,
                 segments: cx
                     .std_path(&[sym::panic, sym::panic_2021])
@@ -42,7 +42,7 @@ pub(crate) fn expand_assert<'cx>(
                     .map(|ident| PathSegment::from_ident(ident))
                     .collect(),
                 tokens: None,
-            }
+            })
         } else {
             // Before edition 2021, we call `panic!()` unqualified,
             // such that it calls either `std::panic!()` or `core::panic!()`.
diff --git a/compiler/rustc_builtin_macros/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
index f15acc154baf3..5c9f01a8dbfbf 100644
--- a/compiler/rustc_builtin_macros/src/assert/context.rs
+++ b/compiler/rustc_builtin_macros/src/assert/context.rs
@@ -69,7 +69,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
     ///   }
     /// }
     /// ```
-    pub(super) fn build(mut self, mut cond_expr: Box<Expr>, panic_path: Path) -> Box<Expr> {
+    pub(super) fn build(mut self, mut cond_expr: Box<Expr>, panic_path: Box<Path>) -> Box<Expr> {
         let expr_str = pprust::expr_to_string(&cond_expr);
         self.manage_cond_expr(&mut cond_expr);
         let initial_imports = self.build_initial_imports();
@@ -142,7 +142,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
     ///     __capture0,
     ///     ...
     /// );
-    fn build_panic(&self, expr_str: &str, panic_path: Path) -> Box<Expr> {
+    fn build_panic(&self, expr_str: &str, panic_path: Box<Path>) -> Box<Expr> {
         let escaped_expr_str = escape_to_fmt(expr_str);
         let initial = [
             TokenTree::token_joint(
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 311a24280cfb7..7916710d9d53d 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -630,7 +630,7 @@ mod llvm_enzyme {
             thin_vec![segment]
         };
 
-        let path = Path { span, segments, tokens: None };
+        let path = Box::new(Path { span, segments, tokens: None });
 
         ecx.expr_path(path)
     }
diff --git a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
index 80296a43ee490..9e443929a4bc2 100644
--- a/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/coerce_pointee.rs
@@ -356,7 +356,7 @@ fn contains_maybe_sized_bound(bounds: &[GenericBound]) -> bool {
     bounds.iter().any(is_maybe_sized_bound)
 }
 
-fn is_sized_marker(path: &ast::Path) -> bool {
+fn is_sized_marker(path: &Box<ast::Path>) -> bool {
     const CORE_UNSIZE: [Symbol; 3] = [sym::core, sym::marker, sym::Sized];
     const STD_UNSIZE: [Symbol; 3] = [sym::std, sym::marker, sym::Sized];
     let segments = || path.segments.iter().map(|segment| segment.ident.name);
diff --git a/compiler/rustc_builtin_macros/src/deriving/debug.rs b/compiler/rustc_builtin_macros/src/deriving/debug.rs
index 004b13bcc333d..2436800d0099d 100644
--- a/compiler/rustc_builtin_macros/src/deriving/debug.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/debug.rs
@@ -167,7 +167,7 @@ fn show_substructure(cx: &ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) ->
         let ty_dyn_debug = cx.ty(
             span,
             ast::TyKind::TraitObject(
-                vec![cx.trait_bound(path_debug, false)],
+                thin_vec![cx.trait_bound(path_debug, false)],
                 ast::TraitObjectSyntax::Dyn,
             ),
         );
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index ff6b15b173ed1..bae879974f647 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -617,7 +617,7 @@ impl<'a> TraitDef<'a> {
                     ident,
                     generics: Generics::default(),
                     after_where_clause: ast::WhereClause::default(),
-                    bounds: Vec::new(),
+                    bounds: ThinVec::new(),
                     ty: Some(type_def.to_ty(cx, self.span, type_ident, generics)),
                 })),
                 tokens: None,
@@ -639,7 +639,7 @@ impl<'a> TraitDef<'a> {
                     // Extra restrictions on the generics parameters to the
                     // type being derived upon.
                     let span = param.ident.span.with_ctxt(ctxt);
-                    let bounds: Vec<_> = self
+                    let bounds: ThinVec<_> = self
                         .additional_bounds
                         .iter()
                         .map(|p| {
@@ -723,7 +723,7 @@ impl<'a> TraitDef<'a> {
                     {
                         continue;
                     }
-                    let mut bounds: Vec<_> = self
+                    let mut bounds: ThinVec<_> = self
                         .additional_bounds
                         .iter()
                         .map(|p| {
@@ -1511,7 +1511,8 @@ impl<'a> TraitDef<'a> {
     fn create_struct_patterns(
         &self,
         cx: &ExtCtxt<'_>,
-        struct_path: ast::Path,
+        // njn: introduce Path::new()?
+        struct_path: Box<ast::Path>,
         struct_def: &'a VariantData,
         prefixes: &[String],
         by_ref: ByRef,
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
index e7972c5436e13..aaaa1cadcfc29 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
@@ -48,7 +48,7 @@ impl Path {
         span: Span,
         self_ty: Ident,
         self_generics: &Generics,
-    ) -> ast::Path {
+    ) -> Box<ast::Path> {
         let mut idents = self.path.iter().map(|s| Ident::new(*s, span)).collect();
         let tys = self.params.iter().map(|t| t.to_ty(cx, span, self_ty, self_generics));
         let params = tys.map(GenericArg::Type).collect();
@@ -112,7 +112,7 @@ impl Ty {
         span: Span,
         self_ty: Ident,
         generics: &Generics,
-    ) -> ast::Path {
+    ) -> Box<ast::Path> {
         match self {
             Self_ => {
                 let params: Vec<_> = generics
diff --git a/compiler/rustc_builtin_macros/src/edition_panic.rs b/compiler/rustc_builtin_macros/src/edition_panic.rs
index 08f555b9e52f6..dc709458a869d 100644
--- a/compiler/rustc_builtin_macros/src/edition_panic.rs
+++ b/compiler/rustc_builtin_macros/src/edition_panic.rs
@@ -48,7 +48,7 @@ fn expand<'cx>(
         cx.expr(
             sp,
             ExprKind::MacCall(Box::new(MacCall {
-                path: Path {
+                path: Box::new(Path {
                     span: sp,
                     segments: cx
                         .std_path(&[sym::panic, mac])
@@ -56,7 +56,7 @@ fn expand<'cx>(
                         .map(|ident| PathSegment::from_ident(ident))
                         .collect(),
                     tokens: None,
-                },
+                }),
                 args: Box::new(DelimArgs {
                     dspan: DelimSpan::from_single(sp),
                     delim: Delimiter::Parenthesis,
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index e08fb81d4de68..547fea0fcc196 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -38,7 +38,7 @@ struct TestCtxt<'a> {
     def_site: Span,
     test_cases: Vec<Test>,
     reexport_test_harness_main: Option<Symbol>,
-    test_runner: Option<ast::Path>,
+    test_runner: Option<Box<ast::Path>>,
 }
 
 /// Traverse the crate, collecting all the test functions, eliding any
@@ -229,7 +229,7 @@ fn generate_test_harness(
     krate: &mut ast::Crate,
     features: &Features,
     panic_strategy: PanicStrategy,
-    test_runner: Option<ast::Path>,
+    test_runner: Option<Box<ast::Path>>,
 ) {
     let econfig = ExpansionConfig::default(sym::test, features);
     let ext_cx = ExtCtxt::new(sess, econfig, resolver, None);
@@ -391,7 +391,7 @@ fn get_test_name(i: &ast::Item) -> Option<Symbol> {
     attr::first_attr_value_str_by_name(&i.attrs, sym::rustc_test_marker)
 }
 
-fn get_test_runner(sess: &Session, krate: &ast::Crate) -> Option<ast::Path> {
+fn get_test_runner(sess: &Session, krate: &ast::Crate) -> Option<Box<ast::Path>> {
     match AttributeParser::parse_limited(sess, &krate.attrs, &[sym::test_runner]) {
         Some(rustc_hir::Attribute::Parsed(AttributeKind::TestRunner(path))) => Some(path),
         _ => None,
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 821f541170f62..736e96ee3adcb 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -1072,7 +1072,7 @@ impl SyntaxExtension {
 pub struct Indeterminate;
 
 pub struct DeriveResolution {
-    pub path: ast::Path,
+    pub path: Box<ast::Path>,
     pub item: Annotatable,
     // FIXME: currently this field is only used in `is_none`/`is_some` conditions. However, the
     // `Arc<SyntaxExtension>` will be used if the FIXME in `MacroExpander::fully_expand_fragment`
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
index 01886a97f55a2..55fb9d9757f61 100644
--- a/compiler/rustc_expand/src/build.rs
+++ b/compiler/rustc_expand/src/build.rs
@@ -11,13 +11,13 @@ use thin_vec::{ThinVec, thin_vec};
 use crate::base::ExtCtxt;
 
 impl<'a> ExtCtxt<'a> {
-    pub fn path(&self, span: Span, strs: Vec<Ident>) -> ast::Path {
+    pub fn path(&self, span: Span, strs: Vec<Ident>) -> Box<ast::Path> {
         self.path_all(span, false, strs, vec![])
     }
-    pub fn path_ident(&self, span: Span, id: Ident) -> ast::Path {
+    pub fn path_ident(&self, span: Span, id: Ident) -> Box<ast::Path> {
         self.path(span, vec![id])
     }
-    pub fn path_global(&self, span: Span, strs: Vec<Ident>) -> ast::Path {
+    pub fn path_global(&self, span: Span, strs: Vec<Ident>) -> Box<ast::Path> {
         self.path_all(span, true, strs, vec![])
     }
     pub fn path_all(
@@ -26,7 +26,7 @@ impl<'a> ExtCtxt<'a> {
         global: bool,
         mut idents: Vec<Ident>,
         args: Vec<ast::GenericArg>,
-    ) -> ast::Path {
+    ) -> Box<ast::Path> {
         assert!(!idents.is_empty());
         let add_root = global && !idents[0].is_path_segment_keyword();
         let mut segments = ThinVec::with_capacity(idents.len() + add_root as usize);
@@ -48,13 +48,13 @@ impl<'a> ExtCtxt<'a> {
             id: ast::DUMMY_NODE_ID,
             args,
         });
-        ast::Path { span, segments, tokens: None }
+        Box::new(ast::Path { span, segments, tokens: None })
     }
 
     pub fn macro_call(
         &self,
         span: Span,
-        path: ast::Path,
+        path: Box<ast::Path>,
         delim: Delimiter,
         tokens: TokenStream,
     ) -> Box<ast::MacCall> {
@@ -80,7 +80,7 @@ impl<'a> ExtCtxt<'a> {
         self.ty(span, ast::TyKind::Infer)
     }
 
-    pub fn ty_path(&self, path: ast::Path) -> Box<ast::Ty> {
+    pub fn ty_path(&self, path: Box<ast::Path>) -> Box<ast::Ty> {
         self.ty(path.span, ast::TyKind::Path(None, path))
     }
 
@@ -180,11 +180,16 @@ impl<'a> ExtCtxt<'a> {
         }
     }
 
-    pub fn trait_ref(&self, path: ast::Path) -> ast::TraitRef {
+    pub fn trait_ref(&self, path: Box<ast::Path>) -> ast::TraitRef {
         ast::TraitRef { path, ref_id: ast::DUMMY_NODE_ID }
     }
 
-    pub fn poly_trait_ref(&self, span: Span, path: ast::Path, is_const: bool) -> ast::PolyTraitRef {
+    pub fn poly_trait_ref(
+        &self,
+        span: Span,
+        path: Box<ast::Path>,
+        is_const: bool,
+    ) -> ast::PolyTraitRef {
         ast::PolyTraitRef {
             bound_generic_params: ThinVec::new(),
             modifiers: ast::TraitBoundModifiers {
@@ -202,7 +207,7 @@ impl<'a> ExtCtxt<'a> {
         }
     }
 
-    pub fn trait_bound(&self, path: ast::Path, is_const: bool) -> ast::GenericBound {
+    pub fn trait_bound(&self, path: Box<ast::Path>, is_const: bool) -> ast::GenericBound {
         ast::GenericBound::Trait(self.poly_trait_ref(path.span, path, is_const))
     }
 
@@ -307,7 +312,7 @@ impl<'a> ExtCtxt<'a> {
         })
     }
 
-    pub fn expr_path(&self, path: ast::Path) -> Box<ast::Expr> {
+    pub fn expr_path(&self, path: Box<ast::Path>) -> Box<ast::Expr> {
         self.expr(path.span, ast::ExprKind::Path(None, path))
     }
 
@@ -411,7 +416,7 @@ impl<'a> ExtCtxt<'a> {
     pub fn expr_struct(
         &self,
         span: Span,
-        path: ast::Path,
+        path: Box<ast::Path>,
         fields: ThinVec<ast::ExprField>,
     ) -> Box<ast::Expr> {
         self.expr(
@@ -554,13 +559,13 @@ impl<'a> ExtCtxt<'a> {
         let pat = PatKind::Ident(ann, ident.with_span_pos(span), None);
         self.pat(span, pat)
     }
-    pub fn pat_path(&self, span: Span, path: ast::Path) -> ast::Pat {
+    pub fn pat_path(&self, span: Span, path: Box<ast::Path>) -> ast::Pat {
         self.pat(span, PatKind::Path(None, path))
     }
     pub fn pat_tuple_struct(
         &self,
         span: Span,
-        path: ast::Path,
+        path: Box<ast::Path>,
         subpats: ThinVec<ast::Pat>,
     ) -> ast::Pat {
         self.pat(span, PatKind::TupleStruct(None, path, subpats))
@@ -568,7 +573,7 @@ impl<'a> ExtCtxt<'a> {
     pub fn pat_struct(
         &self,
         span: Span,
-        path: ast::Path,
+        path: Box<ast::Path>,
         field_pats: ThinVec<ast::PatField>,
     ) -> ast::Pat {
         self.pat(span, PatKind::Struct(None, path, field_pats, ast::PatFieldsRest::None))
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 0fd21e017ff61..bea42dee18b8d 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -386,10 +386,10 @@ pub enum InvocationKind {
         pos: usize,
         item: Annotatable,
         /// Required for resolving derive helper attributes.
-        derives: Vec<ast::Path>,
+        derives: Vec<Box<ast::Path>>,
     },
     Derive {
-        path: ast::Path,
+        path: Box<ast::Path>,
         is_const: bool,
         item: Annotatable,
     },
@@ -2181,7 +2181,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
 
     fn collect_attr(
         &mut self,
-        (attr, pos, derives): (ast::Attribute, usize, Vec<ast::Path>),
+        (attr, pos, derives): (ast::Attribute, usize, Vec<Box<ast::Path>>),
         item: Annotatable,
         kind: AstFragmentKind,
     ) -> AstFragment {
@@ -2203,7 +2203,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
     fn take_first_attr(
         &self,
         item: &mut impl HasAttrs,
-    ) -> Option<(ast::Attribute, usize, Vec<ast::Path>)> {
+    ) -> Option<(ast::Attribute, usize, Vec<Box<ast::Path>>)> {
         let mut attr = None;
 
         let mut cfg_pos = None;
diff --git a/compiler/rustc_expand/src/placeholders.rs b/compiler/rustc_expand/src/placeholders.rs
index 4044a414c5fee..fcfdc0960c8b3 100644
--- a/compiler/rustc_expand/src/placeholders.rs
+++ b/compiler/rustc_expand/src/placeholders.rs
@@ -16,7 +16,7 @@ pub(crate) fn placeholder(
 ) -> AstFragment {
     fn mac_placeholder() -> Box<ast::MacCall> {
         Box::new(ast::MacCall {
-            path: ast::Path { span: DUMMY_SP, segments: ThinVec::new(), tokens: None },
+            path: Box::new(ast::Path { span: DUMMY_SP, segments: ThinVec::new(), tokens: None }),
             args: Box::new(ast::DelimArgs {
                 dspan: ast::tokenstream::DelimSpan::dummy(),
                 delim: Delimiter::Parenthesis,
diff --git a/compiler/rustc_expand/src/stats.rs b/compiler/rustc_expand/src/stats.rs
index d7bd5329da8b3..dcf28f8aacd7d 100644
--- a/compiler/rustc_expand/src/stats.rs
+++ b/compiler/rustc_expand/src/stats.rs
@@ -104,7 +104,7 @@ pub(crate) fn update_attr_macro_stats(
     ecx: &mut ExtCtxt<'_>,
     fragment_kind: AstFragmentKind,
     span: Span,
-    path: &ast::Path,
+    path: &Box<ast::Path>,
     attr: &ast::Attribute,
     item: Annotatable,
     fragment: &AstFragment,
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 17d00863d99d5..f55a88194d999 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -1684,7 +1684,7 @@ pub enum AttributeKind {
     },
 
     /// Represents `#![test_runner(path)]`
-    TestRunner(Path),
+    TestRunner(Box<Path>),
 
     /// Represents `#[thread_local]`
     ThreadLocal,
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 5d1b82b0bb48c..9e54ebcc80227 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -1,5 +1,5 @@
 use rustc_ast::util::{classify, parser};
-use rustc_ast::{self as ast, ExprKind, FnRetTy, HasAttrs as _, StmtKind};
+use rustc_ast::{self as ast, ExprKind, FnRetTy, ForLoop, HasAttrs as _, StmtKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir::{self as hir};
@@ -381,7 +381,7 @@ trait UnusedDelimLint {
                 (cond, UnusedDelimsCtx::WhileCond, true, Some(left), Some(right), true)
             }
 
-            ForLoop { ref iter, ref body, .. } => {
+            ForLoop(ast::ForLoop { ref iter, ref body, .. }) => {
                 (iter, UnusedDelimsCtx::ForIterExpr, true, None, Some(body.span.lo()), true)
             }
 
@@ -703,7 +703,7 @@ impl EarlyLintPass for UnusedParens {
         }
 
         match e.kind {
-            ExprKind::Let(ref pat, _, _, _) | ExprKind::ForLoop { ref pat, .. } => {
+            ExprKind::Let(ref pat, _, _, _) | ExprKind::ForLoop(ForLoop { ref pat, .. }) => {
                 self.check_unused_parens_pat(cx, pat, false, false, (true, true));
             }
             // We ignore parens in cases like `if (((let Some(0) = Some(1))))` because we already
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 7040fc60e4f1a..81e0ab7fce12e 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -67,7 +67,7 @@ pub(super) fn dummy_arg(ident: Ident, guar: ErrorGuaranteed) -> Param {
 pub(super) trait RecoverQPath: Sized + 'static {
     const PATH_STYLE: PathStyle = PathStyle::Expr;
     fn to_ty(&self) -> Option<Box<Ty>>;
-    fn recovered(qself: Option<Box<QSelf>>, path: ast::Path) -> Self;
+    fn recovered(qself: Option<Box<QSelf>>, path: Box<ast::Path>) -> Self;
 }
 
 impl<T: RecoverQPath> RecoverQPath for Box<T> {
@@ -75,7 +75,7 @@ impl<T: RecoverQPath> RecoverQPath for Box<T> {
     fn to_ty(&self) -> Option<Box<Ty>> {
         T::to_ty(self)
     }
-    fn recovered(qself: Option<Box<QSelf>>, path: ast::Path) -> Self {
+    fn recovered(qself: Option<Box<QSelf>>, path: Box<ast::Path>) -> Self {
         Box::new(T::recovered(qself, path))
     }
 }
@@ -85,7 +85,7 @@ impl RecoverQPath for Ty {
     fn to_ty(&self) -> Option<Box<Ty>> {
         Some(Box::new(self.clone()))
     }
-    fn recovered(qself: Option<Box<QSelf>>, path: ast::Path) -> Self {
+    fn recovered(qself: Option<Box<QSelf>>, path: Box<ast::Path>) -> Self {
         Self {
             span: path.span,
             kind: TyKind::Path(qself, path),
@@ -100,7 +100,7 @@ impl RecoverQPath for Pat {
     fn to_ty(&self) -> Option<Box<Ty>> {
         self.to_ty()
     }
-    fn recovered(qself: Option<Box<QSelf>>, path: ast::Path) -> Self {
+    fn recovered(qself: Option<Box<QSelf>>, path: Box<ast::Path>) -> Self {
         Self {
             span: path.span,
             kind: PatKind::Path(qself, path),
@@ -114,7 +114,7 @@ impl RecoverQPath for Expr {
     fn to_ty(&self) -> Option<Box<Ty>> {
         self.to_ty()
     }
-    fn recovered(qself: Option<Box<QSelf>>, path: ast::Path) -> Self {
+    fn recovered(qself: Option<Box<QSelf>>, path: Box<ast::Path>) -> Self {
         Self {
             span: path.span,
             kind: ExprKind::Path(qself, path),
@@ -980,11 +980,11 @@ impl<'a> Parser<'a> {
             // }
             debug!(?maybe_struct_name, ?self.token);
             let mut snapshot = self.create_snapshot_for_diagnostic();
-            let path = Path {
+            let path = Box::new(Path {
                 segments: ThinVec::new(),
                 span: self.prev_token.span.shrink_to_lo(),
                 tokens: None,
-            };
+            });
             let struct_expr = snapshot.parse_expr_struct(None, path, false);
             let block_tail = self.parse_block_tail(lo, s, AttemptLocalParseRecovery::No);
             return Some(match (struct_expr, block_tail) {
@@ -1856,7 +1856,8 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, T> {
         self.expect(exp!(PathSep))?;
 
-        let mut path = ast::Path { segments: ThinVec::new(), span: DUMMY_SP, tokens: None };
+        let mut path =
+            Box::new(ast::Path { segments: ThinVec::new(), span: DUMMY_SP, tokens: None });
         self.parse_path_segments(&mut path.segments, T::PATH_STYLE, None)?;
         path.span = ty_span.to(self.prev_token.span);
 
@@ -2815,14 +2816,14 @@ impl<'a> Parser<'a> {
                                     PatKind::Ident(_, old_ident, _) => {
                                         let path = PatKind::Path(
                                             None,
-                                            Path {
+                                            Box::new(Path {
                                                 span: new_span,
                                                 segments: thin_vec![
                                                     PathSegment::from_ident(*old_ident),
                                                     PathSegment::from_ident(*ident),
                                                 ],
                                                 tokens: None,
-                                            },
+                                            }),
                                         );
                                         first_pat = self.mk_pat(new_span, path);
                                         show_sugg = true;
@@ -2832,7 +2833,11 @@ impl<'a> Parser<'a> {
                                         segments.push(PathSegment::from_ident(*ident));
                                         let path = PatKind::Path(
                                             old_qself.clone(),
-                                            Path { span: new_span, segments, tokens: None },
+                                            Box::new(Path {
+                                                span: new_span,
+                                                segments,
+                                                tokens: None,
+                                            }),
                                         );
                                         first_pat = self.mk_pat(new_span, path);
                                         show_sugg = true;
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 60a94345c5325..a28fa78b99ea2 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -15,7 +15,7 @@ use rustc_ast::visit::{Visitor, walk_expr};
 use rustc_ast::{
     self as ast, AnonConst, Arm, AssignOp, AssignOpKind, AttrStyle, AttrVec, BinOp, BinOpKind,
     BlockCheckMode, CaptureBy, ClosureBinder, DUMMY_NODE_ID, Expr, ExprField, ExprKind, FnDecl,
-    FnRetTy, Guard, Label, MacCall, MetaItemLit, MgcaDisambiguation, Movability, Param,
+    FnRetTy, ForLoop, Guard, Label, MacCall, MetaItemLit, MgcaDisambiguation, Movability, Param,
     RangeLimits, StmtKind, Ty, TyKind, UnOp, UnsafeBinderCastKind, YieldKind,
 };
 use rustc_ast_pretty::pprust;
@@ -1154,8 +1154,8 @@ impl<'a> Parser<'a> {
     /// Parse the field access used in offset_of, matched by `$(e:expr)+`.
     /// Currently returns a list of idents. However, it should be possible in
     /// future to also do array indices, which might be arbitrary expressions.
-    pub(crate) fn parse_floating_field_access(&mut self) -> PResult<'a, Vec<Ident>> {
-        let mut fields = Vec::new();
+    pub(crate) fn parse_floating_field_access(&mut self) -> PResult<'a, ThinVec<Ident>> {
+        let mut fields = ThinVec::new();
         let mut trailing_dot = None;
 
         loop {
@@ -1957,7 +1957,7 @@ impl<'a> Parser<'a> {
                 if label.is_some()
                     && match &expr.kind {
                         ExprKind::While(_, _, None)
-                        | ExprKind::ForLoop { label: None, .. }
+                        | ExprKind::ForLoop(ForLoop { label: None, .. })
                         | ExprKind::Loop(_, None, _) => true,
                         ExprKind::Block(block, None) => {
                             matches!(block.rules, BlockCheckMode::Default)
@@ -3055,7 +3055,13 @@ impl<'a> Parser<'a> {
             let block = self.mk_block(thin_vec![], BlockCheckMode::Default, self.prev_token.span);
             return Ok(self.mk_expr(
                 lo.to(self.prev_token.span),
-                ExprKind::ForLoop { pat, iter: err_expr, body: block, label: opt_label, kind },
+                ExprKind::ForLoop(Box::new(ForLoop {
+                    pat,
+                    iter: err_expr,
+                    body: block,
+                    label: opt_label,
+                    kind,
+                })),
             ));
         }
 
@@ -3065,7 +3071,13 @@ impl<'a> Parser<'a> {
             opt_label.is_none().then_some(lo),
         )?;
 
-        let kind = ExprKind::ForLoop { pat, iter: expr, body: loop_block, label: opt_label, kind };
+        let kind = ExprKind::ForLoop(Box::new(ForLoop {
+            pat,
+            iter: expr,
+            body: loop_block,
+            label: opt_label,
+            kind,
+        }));
 
         self.recover_loop_else("for", lo)?;
 
@@ -3758,7 +3770,7 @@ impl<'a> Parser<'a> {
     fn maybe_parse_struct_expr(
         &mut self,
         qself: &Option<Box<ast::QSelf>>,
-        path: &ast::Path,
+        path: &Box<ast::Path>,
     ) -> Option<PResult<'a, Box<Expr>>> {
         let struct_allowed = !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL);
         match (struct_allowed, self.is_likely_struct_lit()) {
@@ -3848,7 +3860,7 @@ impl<'a> Parser<'a> {
 
     pub(super) fn parse_struct_fields(
         &mut self,
-        pth: ast::Path,
+        pth: Box<ast::Path>, // njn: ref?
         recover: bool,
         close: ExpTokenPair,
     ) -> PResult<
@@ -4032,18 +4044,18 @@ impl<'a> Parser<'a> {
     pub(super) fn parse_expr_struct(
         &mut self,
         qself: Option<Box<ast::QSelf>>,
-        pth: ast::Path,
+        path: Box<ast::Path>,
         recover: bool,
     ) -> PResult<'a, Box<Expr>> {
-        let lo = pth.span;
+        let lo = path.span;
         let (fields, base, recovered_async) =
-            self.parse_struct_fields(pth.clone(), recover, exp!(CloseBrace))?;
+            self.parse_struct_fields(path.clone(), recover, exp!(CloseBrace))?;
         let span = lo.to(self.token.span);
         self.expect(exp!(CloseBrace))?;
         let expr = if let Some(guar) = recovered_async {
             ExprKind::Err(guar)
         } else {
-            ExprKind::Struct(Box::new(ast::StructExpr { qself, path: pth, fields, rest: base }))
+            ExprKind::Struct(Box::new(ast::StructExpr { qself, path, fields, rest: base }))
         };
         Ok(self.mk_expr(span, expr))
     }
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index e2df607fd0f86..506607f57191d 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -26,7 +26,7 @@ impl<'a> Parser<'a> {
     /// BOUND = LT_BOUND (e.g., `'a`)
     /// ```
     fn parse_lt_param_bounds(&mut self) -> GenericBounds {
-        let mut lifetimes = Vec::new();
+        let mut lifetimes = ThinVec::new();
         while self.check_lifetime() {
             lifetimes.push(ast::GenericBound::Outlives(self.expect_lifetime()));
 
@@ -86,7 +86,7 @@ impl<'a> Parser<'a> {
             }
             self.parse_generic_bounds()?
         } else {
-            Vec::new()
+            ThinVec::new()
         };
 
         let default = if self.eat(exp!(Eq)) { Some(self.parse_ty()?) } else { None };
@@ -125,7 +125,7 @@ impl<'a> Parser<'a> {
                     ident,
                     id: ast::DUMMY_NODE_ID,
                     attrs: preceding_attrs,
-                    bounds: Vec::new(),
+                    bounds: ThinVec::new(),
                     kind: GenericParamKind::Const { ty, span, default: None },
                     is_placeholder: false,
                     colon_span: None,
@@ -148,7 +148,7 @@ impl<'a> Parser<'a> {
             ident,
             id: ast::DUMMY_NODE_ID,
             attrs: preceding_attrs,
-            bounds: Vec::new(),
+            bounds: ThinVec::new(),
             kind: GenericParamKind::Const { ty, span, default },
             is_placeholder: false,
             colon_span: None,
@@ -189,7 +189,7 @@ impl<'a> Parser<'a> {
             ident,
             id: ast::DUMMY_NODE_ID,
             attrs: preceding_attrs,
-            bounds: Vec::new(),
+            bounds: ThinVec::new(),
             kind: GenericParamKind::Const { ty, span, default },
             is_placeholder: false,
             colon_span: None,
@@ -225,7 +225,7 @@ impl<'a> Parser<'a> {
                     let (colon_span, bounds) = if this.eat(exp!(Colon)) {
                         (Some(this.prev_token.span), this.parse_lt_param_bounds())
                     } else {
-                        (None, Vec::new())
+                        (None, ThinVec::new())
                     };
 
                     if this.check_noexpect(&token::Eq) && this.look_ahead(1, |t| t.is_lifetime()) {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 16fed9c6c273b..fc05e9b21ffda 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1135,7 +1135,7 @@ impl<'a> Parser<'a> {
         // Parse optional colon and supertrait bounds.
         let had_colon = self.eat(exp!(Colon));
         let span_at_colon = self.prev_token.span;
-        let bounds = if had_colon { self.parse_generic_bounds()? } else { Vec::new() };
+        let bounds = if had_colon { self.parse_generic_bounds()? } else { ThinVec::new() };
 
         let span_before_eq = self.prev_token.span;
         if self.eat(exp!(Eq)) {
@@ -1253,7 +1253,8 @@ impl<'a> Parser<'a> {
         let mut generics = self.parse_generics()?;
 
         // Parse optional colon and param bounds.
-        let bounds = if self.eat(exp!(Colon)) { self.parse_generic_bounds()? } else { Vec::new() };
+        let bounds =
+            if self.eat(exp!(Colon)) { self.parse_generic_bounds()? } else { ThinVec::new() };
         generics.where_clause = self.parse_where_clause()?;
 
         let ty = if self.eat(exp!(Eq)) { Some(self.parse_ty()?) } else { None };
@@ -1285,7 +1286,7 @@ impl<'a> Parser<'a> {
         let lo = self.token.span;
 
         let mut prefix =
-            ast::Path { segments: ThinVec::new(), span: lo.shrink_to_lo(), tokens: None };
+            Box::new(ast::Path { segments: ThinVec::new(), span: lo.shrink_to_lo(), tokens: None });
         let kind =
             if self.check(exp!(OpenBrace)) || self.check(exp!(Star)) || self.is_import_coupler() {
                 // `use *;` or `use ::*;` or `use {...};` or `use ::{...};`
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 64255d51a7c69..1fc28e756f854 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -1509,11 +1509,8 @@ impl<'a> Parser<'a> {
                 self.bump(); // `in`
                 let path = self.parse_path(PathStyle::Mod)?; // `path`
                 self.expect(exp!(CloseParen))?; // `)`
-                let vis = VisibilityKind::Restricted {
-                    path: Box::new(path),
-                    id: ast::DUMMY_NODE_ID,
-                    shorthand: false,
-                };
+                let vis =
+                    VisibilityKind::Restricted { path, id: ast::DUMMY_NODE_ID, shorthand: false };
                 return Ok(Visibility {
                     span: lo.to(self.prev_token.span),
                     kind: vis,
@@ -1526,11 +1523,8 @@ impl<'a> Parser<'a> {
                 self.bump(); // `(`
                 let path = self.parse_path(PathStyle::Mod)?; // `crate`/`super`/`self`
                 self.expect(exp!(CloseParen))?; // `)`
-                let vis = VisibilityKind::Restricted {
-                    path: Box::new(path),
-                    id: ast::DUMMY_NODE_ID,
-                    shorthand: true,
-                };
+                let vis =
+                    VisibilityKind::Restricted { path, id: ast::DUMMY_NODE_ID, shorthand: true };
                 return Ok(Visibility {
                     span: lo.to(self.prev_token.span),
                     kind: vis,
@@ -1602,11 +1596,8 @@ impl<'a> Parser<'a> {
         if self.eat_keyword(exp!(In)) {
             let path = self.parse_path(PathStyle::Mod)?; // `in path`
             self.expect(exp!(CloseParen))?; // `)`
-            let restriction = RestrictionKind::Restricted {
-                path: Box::new(path),
-                id: ast::DUMMY_NODE_ID,
-                shorthand: false,
-            };
+            let restriction =
+                RestrictionKind::Restricted { path, id: ast::DUMMY_NODE_ID, shorthand: false };
             let span = lo.to(self.prev_token.span);
             Ok((restriction, span, span))
         } else if self.look_ahead(1, |t| t == &token::CloseParen)
@@ -1614,11 +1605,8 @@ impl<'a> Parser<'a> {
         {
             let path = self.parse_path(PathStyle::Mod)?; // `crate`/`super`/`self`
             self.expect(exp!(CloseParen))?; // `)`
-            let restriction = RestrictionKind::Restricted {
-                path: Box::new(path),
-                id: ast::DUMMY_NODE_ID,
-                shorthand: true,
-            };
+            let restriction =
+                RestrictionKind::Restricted { path, id: ast::DUMMY_NODE_ID, shorthand: true };
             let span = lo.to(self.prev_token.span);
             Ok((restriction, span, span))
         } else {
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
index 1b1d7ddb24b1b..19de84a75ccef 100644
--- a/compiler/rustc_parse/src/parser/nonterminal.rs
+++ b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -179,9 +179,9 @@ impl<'a> Parser<'a> {
                     }))
                 }
             }
-            NonterminalKind::Path => Ok(ParseNtResult::Path(Box::new(
+            NonterminalKind::Path => Ok(ParseNtResult::Path(
                 self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?,
-            ))),
+            )),
             NonterminalKind::Meta => {
                 Ok(ParseNtResult::Meta(Box::new(self.parse_attr_item(ForceCollect::Yes)?)))
             }
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index b66dcddc8d333..5f8c4d2d35a1a 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1156,7 +1156,7 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse macro invocation
-    fn parse_pat_mac_invoc(&mut self, path: Path) -> PResult<'a, PatKind> {
+    fn parse_pat_mac_invoc(&mut self, path: Box<Path>) -> PResult<'a, PatKind> {
         self.bump();
         let args = self.parse_delim_args()?;
         let mac = Box::new(MacCall { path, args });
@@ -1396,7 +1396,11 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a struct ("record") pattern (e.g. `Foo { ... }` or `Foo::Bar { ... }`).
-    fn parse_pat_struct(&mut self, qself: Option<Box<QSelf>>, path: Path) -> PResult<'a, PatKind> {
+    fn parse_pat_struct(
+        &mut self,
+        qself: Option<Box<QSelf>>,
+        path: Box<Path>,
+    ) -> PResult<'a, PatKind> {
         if qself.is_some() {
             // Feature gate the use of qualified paths in patterns
             self.psess.gated_spans.gate(sym::more_qualified_paths, path.span);
@@ -1417,7 +1421,7 @@ impl<'a> Parser<'a> {
     fn parse_pat_tuple_struct(
         &mut self,
         qself: Option<Box<QSelf>>,
-        path: Path,
+        path: Box<Path>,
     ) -> PResult<'a, PatKind> {
         let (fields, _) = self.parse_paren_comma_seq(|p| {
             p.parse_pat_allow_top_guard(
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index ea86c08915b31..33d819f3e7c01 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -77,7 +77,7 @@ impl<'a> Parser<'a> {
     /// `<T as U>::a`
     /// `<T as U>::F::a<S>` (without disambiguator)
     /// `<T as U>::F::a::<S>` (with disambiguator)
-    pub(super) fn parse_qpath(&mut self, style: PathStyle) -> PResult<'a, (Box<QSelf>, Path)> {
+    pub(super) fn parse_qpath(&mut self, style: PathStyle) -> PResult<'a, (Box<QSelf>, Box<Path>)> {
         let lo = self.prev_token.span;
         let ty = self.parse_ty()?;
 
@@ -92,7 +92,7 @@ impl<'a> Parser<'a> {
             path_span = path_lo.to(self.prev_token.span);
         } else {
             path_span = self.token.span.to(self.token.span);
-            path = ast::Path { segments: ThinVec::new(), span: path_span, tokens: None };
+            path = Box::new(ast::Path { segments: ThinVec::new(), span: path_span, tokens: None });
         }
 
         // See doc comment for `unmatched_angle_bracket_count`.
@@ -112,10 +112,9 @@ impl<'a> Parser<'a> {
             self.parse_path_segments(&mut path.segments, style, None)?;
         }
 
-        Ok((
-            qself,
-            Path { segments: path.segments, span: lo.to(self.prev_token.span), tokens: None },
-        ))
+        path.span = lo.to(self.prev_token.span);
+        path.tokens = None;
+        Ok((qself, path))
     }
 
     /// Recover from an invalid single colon, when the user likely meant a qualified path.
@@ -151,7 +150,7 @@ impl<'a> Parser<'a> {
         true
     }
 
-    pub fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Path> {
+    pub fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Box<Path>> {
         self.parse_path_inner(style, None)
     }
 
@@ -169,8 +168,10 @@ impl<'a> Parser<'a> {
         &mut self,
         style: PathStyle,
         ty_generics: Option<&Generics>,
-    ) -> PResult<'a, Path> {
-        let reject_generics_if_mod_style = |parser: &Parser<'_>, path: Path| {
+    ) -> PResult<'a, Box<Path>> {
+        let reject_generics_if_mod_style = |parser: &Parser<'_>,
+                                            mut path: Box<Path>|
+         -> Box<Path> {
             // Ensure generic arguments don't end up in attribute paths, such as:
             //
             //     macro_rules! m {
@@ -194,10 +195,9 @@ impl<'a> Parser<'a> {
                     .iter()
                     .map(|segment| PathSegment { ident: segment.ident, id: segment.id, args: None })
                     .collect();
-                Path { segments, ..path }
-            } else {
-                path
+                path.segments = segments;
             }
+            path
         };
 
         if let Some(path) =
@@ -221,7 +221,7 @@ impl<'a> Parser<'a> {
             segments.push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
         }
         self.parse_path_segments(&mut segments, style, ty_generics)?;
-        Ok(Path { segments, span: lo.to(self.prev_token.span), tokens: None })
+        Ok(Box::new(Path { segments, span: lo.to(self.prev_token.span), tokens: None }))
     }
 
     pub(super) fn parse_path_segments(
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 5bd2ca3139228..1d068ac85883f 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -238,7 +238,12 @@ impl<'a> Parser<'a> {
 
     /// Parses a statement macro `mac!(args)` provided a `path` representing `mac`.
     /// At this point, the `!` token after the path has already been eaten.
-    fn parse_stmt_mac(&mut self, lo: Span, attrs: AttrVec, path: ast::Path) -> PResult<'a, Stmt> {
+    fn parse_stmt_mac(
+        &mut self,
+        lo: Span,
+        attrs: AttrVec,
+        path: Box<ast::Path>,
+    ) -> PResult<'a, Stmt> {
         let args = self.parse_delim_args()?;
         let hi = self.prev_token.span;
 
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 8a881c6f8b568..fa367e4f1ec53 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -564,7 +564,7 @@ impl<'a> Parser<'a> {
     fn parse_remaining_bounds_path(
         &mut self,
         generic_params: ThinVec<GenericParam>,
-        path: ast::Path,
+        path: Box<ast::Path>,
         lo: Span,
         parse_plus: bool,
         parens: ast::Parens,
@@ -576,7 +576,7 @@ impl<'a> Parser<'a> {
             lo.to(self.prev_token.span),
             parens,
         );
-        let bounds = vec![GenericBound::Trait(poly_trait_ref)];
+        let bounds = thin_vec![GenericBound::Trait(poly_trait_ref)];
         self.parse_remaining_bounds(bounds, parse_plus)
     }
 
@@ -1080,7 +1080,7 @@ impl<'a> Parser<'a> {
     /// Only if `allow_plus` this parses a `+`-separated list of bounds (trailing `+` is admitted).
     /// Otherwise, this only parses a single bound or none.
     fn parse_generic_bounds_common(&mut self, allow_plus: AllowPlus) -> PResult<'a, GenericBounds> {
-        let mut bounds = Vec::new();
+        let mut bounds = ThinVec::new();
 
         // In addition to looping while we find generic bounds:
         // We continue even if we find a keyword. This is necessary for error recovery on,
@@ -1432,7 +1432,7 @@ impl<'a> Parser<'a> {
             // Someone has written something like `&dyn (Trait + Other)`. The correct code
             // would be `&(dyn Trait + Other)`
             if self.token.is_like_plus() && leading_token.is_keyword(kw::Dyn) {
-                let bounds = vec![];
+                let bounds = thin_vec![];
                 self.parse_remaining_bounds(bounds, true)?;
                 self.expect(exp!(CloseParen))?;
                 self.dcx().emit_err(errors::IncorrectParensTraitBounds {
@@ -1453,7 +1453,7 @@ impl<'a> Parser<'a> {
     }
 
     // recovers a `Fn(..)` parenthesized-style path from `fn(..)`
-    fn recover_path_from_fn(&mut self) -> Option<ast::Path> {
+    fn recover_path_from_fn(&mut self) -> Option<Box<ast::Path>> {
         let fn_token_span = self.token.span;
         self.bump();
         let args_lo = self.token.span;
@@ -1463,7 +1463,7 @@ impl<'a> Parser<'a> {
         match self.parse_fn_decl(&mode, AllowPlus::No, RecoverReturnSign::OnlyFatArrow) {
             Ok(decl) => {
                 self.dcx().emit_err(ExpectedFnPathFoundFnKeyword { fn_token_span });
-                Some(ast::Path {
+                Some(Box::new(ast::Path {
                     span: fn_token_span.to(self.prev_token.span),
                     segments: thin_vec![ast::PathSegment {
                         ident: Ident::new(sym::Fn, fn_token_span),
@@ -1478,7 +1478,7 @@ impl<'a> Parser<'a> {
                         ))),
                     }],
                     tokens: None,
-                })
+                }))
             }
             Err(diag) => {
                 diag.cancel();
@@ -1617,7 +1617,7 @@ impl<'a> Parser<'a> {
                 id: lt.id,
                 ident: lt.ident,
                 attrs: ast::AttrVec::new(),
-                bounds: Vec::new(),
+                bounds: ThinVec::new(),
                 is_placeholder: false,
                 kind: ast::GenericParamKind::Lifetime,
                 colon_span: None,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index c94f2f3ffb85d..1fa7e6bfd0bec 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -5320,7 +5320,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 });
             }
 
-            ExprKind::ForLoop { ref pat, ref iter, ref body, label, kind: _ } => {
+            ExprKind::ForLoop(ForLoop { ref pat, ref iter, ref body, label, kind: _ }) => {
                 self.visit_expr(iter);
                 self.with_rib(ValueNS, RibKind::Normal, |this| {
                     this.resolve_pattern_top(pat, PatternSource::For);
@@ -5596,7 +5596,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         }
     }
 
-    fn resolve_define_opaques(&mut self, define_opaque: &Option<ThinVec<(NodeId, Path)>>) {
+    fn resolve_define_opaques(&mut self, define_opaque: &Option<ThinVec<(NodeId, Box<Path>)>>) {
         if let Some(define_opaque) = define_opaque {
             for (id, path) in define_opaque {
                 self.smart_resolve_path(*id, &None, path, PathSource::DefineOpaques);
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 8c5c7f5b2d76d..92f65ee50f381 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -28,7 +28,7 @@ use rustc_session::{Session, lint};
 use rustc_span::edit_distance::{edit_distance, find_best_match_for_name};
 use rustc_span::edition::Edition;
 use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
-use thin_vec::ThinVec;
+use thin_vec::{ThinVec, thin_vec};
 use tracing::debug;
 
 use super::NoConstantGenericsReason;
@@ -4522,11 +4522,15 @@ fn mk_where_bound_predicate(
     let new_where_bound_predicate = ast::WhereBoundPredicate {
         bound_generic_params: ThinVec::new(),
         bounded_ty: Box::new(ty.clone()),
-        bounds: vec![ast::GenericBound::Trait(ast::PolyTraitRef {
+        bounds: thin_vec![ast::GenericBound::Trait(ast::PolyTraitRef {
             bound_generic_params: ThinVec::new(),
             modifiers: ast::TraitBoundModifiers::NONE,
             trait_ref: ast::TraitRef {
-                path: ast::Path { segments: modified_segments, span: DUMMY_SP, tokens: None },
+                path: Box::new(ast::Path {
+                    segments: modified_segments,
+                    span: DUMMY_SP,
+                    tokens: None
+                }),
                 ref_id: DUMMY_NODE_ID,
             },
             span: DUMMY_SP,
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 3b93f2d1fd130..d13dab9e7caad 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -166,7 +166,7 @@ struct ParentScope<'ra> {
     module: Module<'ra>,
     expansion: LocalExpnId,
     macro_rules: MacroRulesScopeRef<'ra>,
-    derives: &'ra [ast::Path],
+    derives: &'ra [Box<ast::Path>],
 }
 
 impl<'ra> ParentScope<'ra> {
@@ -1553,7 +1553,7 @@ pub struct ResolverArenas<'ra> {
     modules: TypedArena<ModuleData<'ra>>,
     imports: TypedArena<ImportData<'ra>>,
     name_resolutions: TypedArena<CmRefCell<NameResolution<'ra>>>,
-    ast_paths: TypedArena<ast::Path>,
+    ast_paths: TypedArena<Box<ast::Path>>, // njn: weird
     macros: TypedArena<Arc<SyntaxExtension>>,
     dropless: DroplessArena,
 }
@@ -1600,7 +1600,7 @@ impl<'ra> ResolverArenas<'ra> {
     fn alloc_macro_rules_decl(&'ra self, decl: MacroRulesDecl<'ra>) -> &'ra MacroRulesDecl<'ra> {
         self.dropless.alloc(decl)
     }
-    fn alloc_ast_paths(&'ra self, paths: &[ast::Path]) -> &'ra [ast::Path] {
+    fn alloc_ast_paths(&'ra self, paths: &[Box<ast::Path>]) -> &'ra [Box<ast::Path>] {
         self.ast_paths.alloc_from_iter(paths.iter().cloned())
     }
     fn alloc_macro(&'ra self, ext: SyntaxExtension) -> &'ra Arc<SyntaxExtension> {
diff --git a/src/tools/clippy/clippy_lints/src/visibility.rs b/src/tools/clippy/clippy_lints/src/visibility.rs
index 9cefc54598b78..15a648b278d8c 100644
--- a/src/tools/clippy/clippy_lints/src/visibility.rs
+++ b/src/tools/clippy/clippy_lints/src/visibility.rs
@@ -88,7 +88,7 @@ impl EarlyLintPass for Visibility {
         if !item.span.in_external_macro(cx.sess().source_map())
             && let VisibilityKind::Restricted { path, shorthand, .. } = &item.vis.kind
         {
-            if **path == kw::SelfLower && !is_from_proc_macro(cx, item.vis.span) {
+            if *path == kw::SelfLower && !is_from_proc_macro(cx, item.vis.span) {
                 span_lint_and_then(
                     cx,
                     NEEDLESS_PUB_SELF,
@@ -105,7 +105,7 @@ impl EarlyLintPass for Visibility {
                 );
             }
 
-            if (**path == kw::Super || **path == kw::SelfLower || **path == kw::Crate)
+            if (*path == kw::Super || *path == kw::SelfLower || *path == kw::Crate)
                 && !*shorthand
                 && let [.., last] = &*path.segments
                 && !is_from_proc_macro(cx, item.vis.span)
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
index fa93cf208c9d9..87c0329fe6906 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -182,22 +182,13 @@ fn eq_expr(l: &Expr, r: &Expr) -> bool {
         (While(lc, lt, ll), While(rc, rt, rl)) => {
             eq_label(ll.as_ref(), rl.as_ref()) && eq_expr(lc, rc) && eq_block(lt, rt)
         },
-        (
-            ForLoop {
-                pat: lp,
-                iter: li,
-                body: lt,
-                label: ll,
-                kind: lk,
-            },
-            ForLoop {
-                pat: rp,
-                iter: ri,
-                body: rt,
-                label: rl,
-                kind: rk,
-            },
-        ) => eq_label(ll.as_ref(), rl.as_ref()) && eq_pat(lp, rp) && eq_expr(li, ri) && eq_block(lt, rt) && lk == rk,
+        (ForLoop(lf), ForLoop(rf)) => {
+            eq_label(lf.label.as_ref(), rf.label.as_ref())
+                && eq_pat(&lf.pat, &rf.pat)
+                && eq_expr(&lf.iter, &rf.iter)
+                && eq_block(&lf.body, &rf.body)
+                && lf.kind == rf.kind
+        }
         (Loop(lt, ll, _), Loop(rt, rl, _)) => eq_label(ll.as_ref(), rl.as_ref()) && eq_block(lt, rt),
         (Block(lb, ll), Block(rb, rl)) => eq_label(ll.as_ref(), rl.as_ref()) && eq_block(lb, rb),
         (TryBlock(lb, lt), TryBlock(rb, rt)) => eq_block(lb, rb) && both(lt.as_deref(), rt.as_deref(), eq_ty),
diff --git a/src/tools/rustfmt/src/expr.rs b/src/tools/rustfmt/src/expr.rs
index 8a3674bff1ca6..28077d7c9a139 100644
--- a/src/tools/rustfmt/src/expr.rs
+++ b/src/tools/rustfmt/src/expr.rs
@@ -778,15 +778,9 @@ fn to_control_flow(expr: &ast::Expr, expr_type: ExprType) -> Option<ControlFlow<
                 expr.span,
             ))
         }
-        ast::ExprKind::ForLoop {
-            ref pat,
-            ref iter,
-            ref body,
-            label,
-            kind,
-        } => Some(ControlFlow::new_for(
-            pat, iter, body, label, expr.span, kind,
-        )),
+        ast::ExprKind::ForLoop(ref f) => {
+            Some(ControlFlow::new_for(&f.pat, &f.iter, &f.body, f.label, expr.span, f.kind))
+        }
         ast::ExprKind::Loop(ref block, label, _) => {
             Some(ControlFlow::new_loop(block, label, expr.span))
         }
diff --git a/tests/ui-fulldeps/pprust-expr-roundtrip.rs b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
index 84f9a09990fdd..6a4f00b01ee37 100644
--- a/tests/ui-fulldeps/pprust-expr-roundtrip.rs
+++ b/tests/ui-fulldeps/pprust-expr-roundtrip.rs
@@ -49,7 +49,7 @@ fn expr(kind: ExprKind) -> Box<Expr> {
 
 fn make_x() -> Box<Expr> {
     let seg = PathSegment::from_ident(Ident::from_str("x"));
-    let path = Path { segments: thin_vec![seg], span: DUMMY_SP, tokens: None };
+    let path = Box::new(Path { segments: thin_vec![seg], span: DUMMY_SP, tokens: None });
     expr(ExprKind::Path(None, path))
 }
 
diff --git a/tests/ui/stats/input-stats.stderr b/tests/ui/stats/input-stats.stderr
index b4d8277a46c00..c42ad793bb69d 100644
--- a/tests/ui/stats/input-stats.stderr
+++ b/tests/ui/stats/input-stats.stderr
@@ -16,23 +16,23 @@ ast-stats - Ref                       64 (NN.N%)             1
 ast-stats - ImplicitSelf             128 (NN.N%)             2
 ast-stats - Path                     640 (NN.N%)            10
 ast-stats PathSegment              864 (NN.N%)            36            24
-ast-stats Expr                     648 (NN.N%)             9            72
-ast-stats - InlineAsm                 72 (NN.N%)             1
-ast-stats - Match                     72 (NN.N%)             1
-ast-stats - Path                      72 (NN.N%)             1
-ast-stats - Struct                    72 (NN.N%)             1
-ast-stats - Lit                      144 (NN.N%)             2
-ast-stats - Block                    216 (NN.N%)             3
-ast-stats Pat                      560 (NN.N%)             7            80
-ast-stats - Struct                    80 (NN.N%)             1
-ast-stats - Wild                      80 (NN.N%)             1
-ast-stats - Ident                    400 (NN.N%)             5
-ast-stats GenericParam             480 (NN.N%)             5            96
-ast-stats GenericBound             352 (NN.N%)             4            88
-ast-stats - Trait                    352 (NN.N%)             4
+ast-stats Expr                     576 (NN.N%)             9            64
+ast-stats - InlineAsm                 64 (NN.N%)             1
+ast-stats - Match                     64 (NN.N%)             1
+ast-stats - Path                      64 (NN.N%)             1
+ast-stats - Struct                    64 (NN.N%)             1
+ast-stats - Lit                      128 (NN.N%)             2
+ast-stats - Block                    192 (NN.N%)             3
+ast-stats Pat                      448 (NN.N%)             7            64
+ast-stats - Struct                    64 (NN.N%)             1
+ast-stats - Wild                      64 (NN.N%)             1
+ast-stats - Ident                    320 (NN.N%)             5
+ast-stats GenericParam             400 (NN.N%)             5            80
 ast-stats AssocItem                320 (NN.N%)             4            80
 ast-stats - Fn                       160 (NN.N%)             2
 ast-stats - Type                     160 (NN.N%)             2
+ast-stats GenericBound             288 (NN.N%)             4            72
+ast-stats - Trait                    288 (NN.N%)             4
 ast-stats FieldDef                 272 (NN.N%)             2           136
 ast-stats Variant                  208 (NN.N%)             2           104
 ast-stats Block                    192 (NN.N%)             6            32
@@ -50,14 +50,14 @@ ast-stats Local                     96 (NN.N%)             1            96
 ast-stats Arm                       96 (NN.N%)             2            48
 ast-stats ForeignItem               80 (NN.N%)             1            80
 ast-stats - Fn                        80 (NN.N%)             1
-ast-stats WherePredicate            72 (NN.N%)             1            72
-ast-stats - BoundPredicate            72 (NN.N%)             1
+ast-stats WherePredicate            56 (NN.N%)             1            56
+ast-stats - BoundPredicate            56 (NN.N%)             1
 ast-stats ExprField                 48 (NN.N%)             1            48
 ast-stats GenericArgs               40 (NN.N%)             1            40
 ast-stats - AngleBracketed            40 (NN.N%)             1
 ast-stats Crate                     40 (NN.N%)             1            40
 ast-stats ----------------------------------------------------------------
-ast-stats Total                  7_624                   127
+ast-stats Total                  7_280                   127
 ast-stats ================================================================
 hir-stats ================================================================
 hir-stats HIR STATS: input_stats