diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 8e4f4c8e71a2e..92d663cd6c8ce 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -353,8 +353,8 @@ pub enum GenericParamKind {
     },
     Const {
         ty: P<Ty>,
-        /// Span of the `const` keyword.
-        kw_span: Span,
+        /// Span of the whole parameter definition, including default.
+        span: Span,
         /// Optional default value for the const generic param.
         default: Option<AnonConst>,
     },
@@ -378,10 +378,7 @@ impl GenericParam {
                 self.ident.span
             }
             GenericParamKind::Type { default: Some(ty) } => self.ident.span.to(ty.span),
-            GenericParamKind::Const { kw_span, default: Some(default), .. } => {
-                kw_span.to(default.value.span)
-            }
-            GenericParamKind::Const { kw_span, default: None, ty } => kw_span.to(ty.span),
+            GenericParamKind::Const { span, .. } => *span,
         }
     }
 }
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index 2afbd979c3023..3b92e39d86667 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -367,7 +367,7 @@ where
 }
 
 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_attrs<T: MutVisitor>(vis: &mut T, attrs: &mut AttrVec) {
+pub fn visit_attrs<T: MutVisitor>(vis: &mut T, attrs: &mut AttrVec) {
     for attr in attrs.iter_mut() {
         vis.visit_attribute(attr);
     }
@@ -626,7 +626,7 @@ fn walk_local<T: MutVisitor>(vis: &mut T, local: &mut P<Local>) {
     vis.visit_span(span);
 }
 
-fn walk_attribute<T: MutVisitor>(vis: &mut T, attr: &mut Attribute) {
+pub fn walk_attribute<T: MutVisitor>(vis: &mut T, attr: &mut Attribute) {
     let Attribute { kind, id: _, style: _, span } = attr;
     match kind {
         AttrKind::Normal(normal) => {
@@ -825,7 +825,7 @@ fn visit_nonterminal<T: MutVisitor>(vis: &mut T, nt: &mut token::Nonterminal) {
 }
 
 // No `noop_` prefix because there isn't a corresponding method in `MutVisitor`.
-fn visit_defaultness<T: MutVisitor>(vis: &mut T, defaultness: &mut Defaultness) {
+pub fn visit_defaultness<T: MutVisitor>(vis: &mut T, defaultness: &mut Defaultness) {
     match defaultness {
         Defaultness::Default(span) => vis.visit_span(span),
         Defaultness::Final => {}
@@ -860,7 +860,8 @@ fn visit_constness<T: MutVisitor>(vis: &mut T, constness: &mut Const) {
 fn walk_closure_binder<T: MutVisitor>(vis: &mut T, binder: &mut ClosureBinder) {
     match binder {
         ClosureBinder::NotPresent => {}
-        ClosureBinder::For { span: _, generic_params } => {
+        ClosureBinder::For { span, generic_params } => {
+            vis.visit_span(span);
             generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
         }
     }
@@ -878,7 +879,7 @@ fn walk_coroutine_kind<T: MutVisitor>(vis: &mut T, coroutine_kind: &mut Coroutin
     }
 }
 
-fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
+pub fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
     match kind {
         FnKind::Fn(FnSig { header, decl, span }, generics, body) => {
             // Identifier and visibility are visited as a part of the item.
@@ -890,8 +891,9 @@ fn walk_fn<T: MutVisitor>(vis: &mut T, kind: FnKind<'_>) {
             }
             vis.visit_span(span);
         }
-        FnKind::Closure(binder, decl, body) => {
+        FnKind::Closure(binder, coroutine_kind, decl, body) => {
             vis.visit_closure_binder(binder);
+            coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
             vis.visit_fn_decl(decl);
             vis.visit_expr(body);
         }
@@ -904,7 +906,7 @@ fn walk_fn_decl<T: MutVisitor>(vis: &mut T, decl: &mut P<FnDecl>) {
     walk_fn_ret_ty(vis, output);
 }
 
-fn walk_fn_ret_ty<T: MutVisitor>(vis: &mut T, fn_ret_ty: &mut FnRetTy) {
+pub fn walk_fn_ret_ty<T: MutVisitor>(vis: &mut T, fn_ret_ty: &mut FnRetTy) {
     match fn_ret_ty {
         FnRetTy::Default(span) => vis.visit_span(span),
         FnRetTy::Ty(ty) => vis.visit_ty(ty),
@@ -924,6 +926,22 @@ fn walk_param_bound<T: MutVisitor>(vis: &mut T, pb: &mut GenericBound) {
     }
 }
 
+fn walk_trait_bound_modifier<T: MutVisitor>(vis: &mut T, tbm: &mut TraitBoundModifiers) {
+    let TraitBoundModifiers { constness, asyncness, polarity } = tbm;
+    match constness {
+        BoundConstness::Never => {}
+        BoundConstness::Always(span) | BoundConstness::Maybe(span) => vis.visit_span(span),
+    }
+    match asyncness {
+        BoundAsyncness::Normal => {}
+        BoundAsyncness::Async(span) => vis.visit_span(span),
+    }
+    match polarity {
+        BoundPolarity::Positive => {}
+        BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => vis.visit_span(span),
+    }
+}
+
 fn walk_precise_capturing_arg<T: MutVisitor>(vis: &mut T, arg: &mut PreciseCapturingArg) {
     match arg {
         PreciseCapturingArg::Lifetime(lt) => {
@@ -950,8 +968,9 @@ pub fn walk_flat_map_generic_param<T: MutVisitor>(
         GenericParamKind::Type { default } => {
             visit_opt(default, |default| vis.visit_ty(default));
         }
-        GenericParamKind::Const { ty, kw_span: _, default } => {
+        GenericParamKind::Const { ty, span, default } => {
             vis.visit_ty(ty);
+            vis.visit_span(span);
             visit_opt(default, |default| vis.visit_anon_const(default));
         }
     }
@@ -1034,9 +1053,10 @@ fn walk_trait_ref<T: MutVisitor>(vis: &mut T, TraitRef { path, ref_id }: &mut Tr
 }
 
 fn walk_poly_trait_ref<T: MutVisitor>(vis: &mut T, p: &mut PolyTraitRef) {
-    let PolyTraitRef { bound_generic_params, modifiers: _, trait_ref, span } = p;
+    let PolyTraitRef { bound_generic_params, modifiers, trait_ref, span } = p;
     bound_generic_params.flat_map_in_place(|param| vis.flat_map_generic_param(param));
     vis.visit_trait_ref(trait_ref);
+    walk_trait_bound_modifier(vis, modifiers);
     vis.visit_span(span);
 }
 
@@ -1376,22 +1396,32 @@ pub fn walk_pat<T: MutVisitor>(vis: &mut T, pat: &mut P<Pat>) {
     vis.visit_span(span);
 }
 
-fn walk_anon_const<T: MutVisitor>(vis: &mut T, AnonConst { id, value }: &mut AnonConst) {
+pub fn walk_anon_const<T: MutVisitor>(vis: &mut T, AnonConst { id, value }: &mut AnonConst) {
     vis.visit_id(id);
     vis.visit_expr(value);
 }
 
 fn walk_inline_asm<T: MutVisitor>(vis: &mut T, asm: &mut InlineAsm) {
-    // FIXME: Visit spans inside all this currently ignored stuff.
     let InlineAsm {
         asm_macro: _,
-        template: _,
-        template_strs: _,
+        template,
+        template_strs,
         operands,
-        clobber_abis: _,
+        clobber_abis,
         options: _,
-        line_spans: _,
+        line_spans,
     } = asm;
+    for piece in template.iter_mut() {
+        match piece {
+            InlineAsmTemplatePiece::String(_str) => {}
+            InlineAsmTemplatePiece::Placeholder { operand_idx: _, modifier: _, span } => {
+                vis.visit_span(span)
+            }
+        }
+    }
+    for (_s1, _s2, span) in template_strs.iter_mut() {
+        vis.visit_span(span)
+    }
     for (op, span) in operands {
         match op {
             InlineAsmOperand::In { expr, reg: _ }
@@ -1410,6 +1440,12 @@ fn walk_inline_asm<T: MutVisitor>(vis: &mut T, asm: &mut InlineAsm) {
         }
         vis.visit_span(span);
     }
+    for (_s1, span) in clobber_abis.iter_mut() {
+        vis.visit_span(span)
+    }
+    for span in line_spans.iter_mut() {
+        vis.visit_span(span)
+    }
 }
 
 fn walk_inline_asm_sym<T: MutVisitor>(
@@ -1422,8 +1458,7 @@ fn walk_inline_asm_sym<T: MutVisitor>(
 }
 
 fn walk_format_args<T: MutVisitor>(vis: &mut T, fmt: &mut FormatArgs) {
-    // FIXME: visit the template exhaustively.
-    let FormatArgs { span, template: _, arguments } = fmt;
+    let FormatArgs { span, template, arguments } = fmt;
     for FormatArgument { kind, expr } in arguments.all_args_mut() {
         match kind {
             FormatArgumentKind::Named(ident) | FormatArgumentKind::Captured(ident) => {
@@ -1433,9 +1468,48 @@ fn walk_format_args<T: MutVisitor>(vis: &mut T, fmt: &mut FormatArgs) {
         }
         vis.visit_expr(expr);
     }
+    for piece in template.iter_mut() {
+        match piece {
+            FormatArgsPiece::Literal(_symbol) => {}
+            FormatArgsPiece::Placeholder(placeholder) => walk_format_placeholder(vis, placeholder),
+        }
+    }
     vis.visit_span(span);
 }
 
+fn walk_format_placeholder<T: MutVisitor>(
+    vis: &mut T,
+    FormatPlaceholder { argument, span, format_options, format_trait: _ }: &mut FormatPlaceholder,
+) {
+    visit_opt(span, |span| vis.visit_span(span));
+    let FormatArgPosition { span, index: _, kind: _ } = argument;
+    visit_opt(span, |span| vis.visit_span(span));
+    let FormatOptions {
+        width,
+        precision,
+        alignment: _,
+        fill: _,
+        sign: _,
+        alternate: _,
+        zero_pad: _,
+        debug_hex: _,
+    } = format_options;
+    match width {
+        None => {}
+        Some(FormatCount::Literal(_)) => {}
+        Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => {
+            visit_opt(span, |span| vis.visit_span(span))
+        }
+    }
+    match precision {
+        None => {}
+        Some(FormatCount::Literal(_)) => {}
+        Some(FormatCount::Argument(FormatArgPosition { span, index: _, kind: _ })) => {
+            visit_opt(span, |span| vis.visit_span(span))
+        }
+    }
+}
+
 pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, tokens }: &mut Expr) {
     vis.visit_id(id);
     visit_attrs(vis, attrs);
@@ -1466,7 +1540,8 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             visit_thin_exprs(vis, call_args);
             vis.visit_span(span);
         }
-        ExprKind::Binary(_binop, lhs, rhs) => {
+        ExprKind::Binary(Spanned { node: _binop, span }, lhs, rhs) => {
+            vis.visit_span(span);
             vis.visit_expr(lhs);
             vis.visit_expr(rhs);
         }
@@ -1522,9 +1597,8 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             fn_arg_span,
         }) => {
             visit_constness(vis, constness);
-            coroutine_kind.as_mut().map(|coroutine_kind| vis.visit_coroutine_kind(coroutine_kind));
             vis.visit_capture_by(capture_clause);
-            vis.visit_fn(FnKind::Closure(binder, fn_decl, body), *span, *id);
+            vis.visit_fn(FnKind::Closure(binder, coroutine_kind, fn_decl, body), *span, *id);
             vis.visit_span(fn_decl_span);
             vis.visit_span(fn_arg_span);
         }
@@ -1532,9 +1606,10 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             visit_opt(label, |label| vis.visit_label(label));
             vis.visit_block(blk);
         }
-        ExprKind::Gen(_capture_by, body, _kind, decl_span) => {
+        ExprKind::Gen(capture_clause, body, _kind, decl_span) => {
             vis.visit_block(body);
             vis.visit_span(decl_span);
+            vis.visit_capture_by(capture_clause);
         }
         ExprKind::Await(expr, await_kw_span) => {
             vis.visit_expr(expr);
@@ -1545,7 +1620,8 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             vis.visit_expr(er);
             vis.visit_span(span);
         }
-        ExprKind::AssignOp(_op, el, er) => {
+        ExprKind::AssignOp(Spanned { node: _binop, span }, el, er) => {
+            vis.visit_span(span);
             vis.visit_expr(el);
             vis.visit_expr(er);
         }
@@ -1597,7 +1673,7 @@ pub fn walk_expr<T: MutVisitor>(vis: &mut T, Expr { kind, id, span, attrs, token
             fields.flat_map_in_place(|field| vis.flat_map_expr_field(field));
             match rest {
                 StructRest::Base(expr) => vis.visit_expr(expr),
-                StructRest::Rest(_span) => {}
+                StructRest::Rest(span) => vis.visit_span(span),
                 StructRest::None => {}
             }
         }
@@ -1630,6 +1706,7 @@ pub fn walk_flat_map_stmt<T: MutVisitor>(
     Stmt { kind, mut span, mut id }: Stmt,
 ) -> SmallVec<[Stmt; 1]> {
     vis.visit_id(&mut id);
+    vis.visit_span(&mut span);
     let stmts: SmallVec<_> = walk_flat_map_stmt_kind(vis, kind)
         .into_iter()
         .map(|kind| Stmt { id, kind, span })
@@ -1640,7 +1717,6 @@ pub fn walk_flat_map_stmt<T: MutVisitor>(
              the visitor should implement custom statement visiting"
         );
     }
-    vis.visit_span(&mut span);
     stmts
 }
 
@@ -1788,5 +1864,10 @@ pub enum FnKind<'a> {
     Fn(&'a mut FnSig, &'a mut Generics, &'a mut Option<P<Block>>),
 
     /// E.g., `|x, y| body`.
-    Closure(&'a mut ClosureBinder, &'a mut P<FnDecl>, &'a mut P<Expr>),
+    Closure(
+        &'a mut ClosureBinder,
+        &'a mut Option<CoroutineKind>,
+        &'a mut P<FnDecl>,
+        &'a mut P<Expr>,
+    ),
 }
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index eb71ec5f4ec93..231b3ceb72210 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -753,7 +753,7 @@ pub fn walk_generic_param<'a, V: Visitor<'a>>(
     match kind {
         GenericParamKind::Lifetime => (),
         GenericParamKind::Type { default } => visit_opt!(visitor, visit_ty, default),
-        GenericParamKind::Const { ty, default, kw_span: _ } => {
+        GenericParamKind::Const { ty, default, span: _ } => {
             try_visit!(visitor.visit_ty(ty));
             visit_opt!(visitor, visit_anon_const, default);
         }
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 6585a7de24591..c98ec1dff24c6 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -249,7 +249,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         hir::InlineAsmOperand::Label { block: self.lower_block(block, false) }
                     }
                 };
-                (op, self.lower_span(*op_sp))
+                (op, *op_sp)
             })
             .collect();
 
@@ -457,7 +457,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             late: true,
                             expr: None,
                         },
-                        self.lower_span(abi_span),
+                        abi_span,
                     ));
                     clobbered.insert(clobber);
                 }
@@ -467,12 +467,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let operands = self.arena.alloc_from_iter(operands);
         let template = self.arena.alloc_from_iter(asm.template.iter().cloned());
         let template_strs = self.arena.alloc_from_iter(
-            asm.template_strs
-                .iter()
-                .map(|(sym, snippet, span)| (*sym, *snippet, self.lower_span(*span))),
+            asm.template_strs.iter().map(|(sym, snippet, span)| (*sym, *snippet, *span)),
         );
-        let line_spans =
-            self.arena.alloc_from_iter(asm.line_spans.iter().map(|span| self.lower_span(*span)));
+        let line_spans = self.arena.alloc_from_iter(asm.line_spans.iter().copied());
         let hir_asm = hir::InlineAsm {
             asm_macro: asm.asm_macro,
             template,
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index 9d2b5690c23d9..8d6b3616c24da 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -21,7 +21,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let (stmts, expr) = self.lower_stmts(&b.stmts);
         let rules = self.lower_block_check_mode(&b.rules);
         let hir_id = self.lower_node_id(b.id);
-        hir::Block { hir_id, stmts, expr, rules, span: self.lower_span(b.span), targeted_by_break }
+        hir::Block { hir_id, stmts, expr, rules, span: b.span, targeted_by_break }
     }
 
     fn lower_stmts(
@@ -37,7 +37,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     let local = self.lower_local(local);
                     self.alias_attrs(hir_id, local.hir_id);
                     let kind = hir::StmtKind::Let(local);
-                    let span = self.lower_span(s.span);
+                    let span = s.span;
                     stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Item(it) => {
@@ -48,7 +48,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 _ => self.next_id(),
                             };
                             let kind = hir::StmtKind::Item(item_id);
-                            let span = self.lower_span(s.span);
+                            let span = s.span;
                             hir::Stmt { hir_id, kind, span }
                         },
                     ));
@@ -61,7 +61,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         let hir_id = self.lower_node_id(s.id);
                         self.alias_attrs(hir_id, e.hir_id);
                         let kind = hir::StmtKind::Expr(e);
-                        let span = self.lower_span(s.span);
+                        let span = s.span;
                         stmts.push(hir::Stmt { hir_id, kind, span });
                     }
                 }
@@ -70,7 +70,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     let hir_id = self.lower_node_id(s.id);
                     self.alias_attrs(hir_id, e.hir_id);
                     let kind = hir::StmtKind::Semi(e);
-                    let span = self.lower_span(s.span);
+                    let span = s.span;
                     stmts.push(hir::Stmt { hir_id, kind, span });
                 }
                 StmtKind::Empty => {}
@@ -94,7 +94,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         } else {
             None
         };
-        let span = self.lower_span(l.span);
+        let span = l.span;
         let source = hir::LocalSource::Normal;
         self.lower_attrs(hir_id, &l.attrs);
         self.arena.alloc(hir::LetStmt { hir_id, ty, pat, init, els, span, source })
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 3b85f1737bdd9..c48df0527a9da 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -88,7 +88,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         delegation: &Delegation,
         item_id: NodeId,
     ) -> DelegationResults<'hir> {
-        let span = self.lower_span(delegation.path.segments.last().unwrap().ident.span);
+        let span = delegation.path.segments.last().unwrap().ident.span;
         let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span);
         match sig_id {
             Ok(sig_id) => {
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index a1a16d0ca2632..e61e9ab73ef86 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -10,7 +10,7 @@ use rustc_middle::span_bug;
 use rustc_session::errors::report_lit_error;
 use rustc_span::source_map::{Spanned, respan};
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
-use rustc_span::{DUMMY_SP, DesugaringKind, Span};
+use rustc_span::{DesugaringKind, Span};
 use thin_vec::{ThinVec, thin_vec};
 
 use super::errors::{
@@ -42,7 +42,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let mut ex = self.lower_expr_mut(ex);
                     // Include parens in span, but only if it is a super-span.
                     if e.span.contains(ex.span) {
-                        ex.span = self.lower_span(e.span);
+                        ex.span = e.span;
                     }
                     // Merge attributes into the inner expression.
                     if !e.attrs.is_empty() {
@@ -115,7 +115,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let receiver = self.lower_expr(receiver);
                     let args =
                         self.arena.alloc_from_iter(args.iter().map(|x| self.lower_expr_mut(x)));
-                    hir::ExprKind::MethodCall(hir_seg, receiver, args, self.lower_span(*span))
+                    hir::ExprKind::MethodCall(hir_seg, receiver, args, *span)
                 }
                 ExprKind::Binary(binop, lhs, rhs) => {
                     let binop = self.lower_binop(*binop);
@@ -137,14 +137,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             LitKind::Err(guar)
                         }
                     };
-                    let lit = self.arena.alloc(respan(self.lower_span(e.span), lit_kind));
+                    let lit = self.arena.alloc(respan(e.span, lit_kind));
                     hir::ExprKind::Lit(lit)
                 }
                 ExprKind::IncludedBytes(bytes) => {
-                    let lit = self.arena.alloc(respan(
-                        self.lower_span(e.span),
-                        LitKind::ByteStr(bytes.clone(), StrStyle::Cooked),
-                    ));
+                    let lit = self
+                        .arena
+                        .alloc(respan(e.span, LitKind::ByteStr(bytes.clone(), StrStyle::Cooked)));
                     hir::ExprKind::Lit(lit)
                 }
                 ExprKind::Cast(expr, ty) => {
@@ -165,7 +164,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::Let(pat, scrutinee, span, recovered) => {
                     hir::ExprKind::Let(self.arena.alloc(hir::LetExpr {
-                        span: self.lower_span(*span),
+                        span: *span,
                         pat: self.lower_pat(pat),
                         ty: None,
                         init: self.lower_expr(scrutinee),
@@ -182,9 +181,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::Loop(body, opt_label, span) => self.with_loop_scope(e.id, |this| {
                     hir::ExprKind::Loop(
                         this.lower_block(body, false),
-                        this.lower_label(*opt_label),
+                        *opt_label,
                         hir::LoopSource::Loop,
-                        this.lower_span(*span),
+                        *span,
                     )
                 }),
                 ExprKind::TryBlock(body) => self.lower_expr_try_block(body),
@@ -196,7 +195,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         MatchKind::Postfix => hir::MatchSource::Postfix,
                     },
                 ),
-                ExprKind::Await(expr, await_kw_span) => self.lower_expr_await(*await_kw_span, expr),
+                ExprKind::Await(expr, await_kw_span) => {
+                    self.lower_expr_await(*await_kw_span, e.span, expr)
+                }
                 ExprKind::Closure(box Closure {
                     binder,
                     capture_clause,
@@ -250,8 +251,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     )
                 }
                 ExprKind::Block(blk, opt_label) => {
-                    let opt_label = self.lower_label(*opt_label);
-                    hir::ExprKind::Block(self.lower_block(blk, opt_label.is_some()), opt_label)
+                    hir::ExprKind::Block(self.lower_block(blk, opt_label.is_some()), *opt_label)
                 }
                 ExprKind::Assign(el, er, span) => self.lower_expr_assign(el, er, *span, e.span),
                 ExprKind::AssignOp(op, el, er) => hir::ExprKind::AssignOp(
@@ -259,9 +259,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.lower_expr(el),
                     self.lower_expr(er),
                 ),
-                ExprKind::Field(el, ident) => {
-                    hir::ExprKind::Field(self.lower_expr(el), self.lower_ident(*ident))
-                }
+                ExprKind::Field(el, ident) => hir::ExprKind::Field(self.lower_expr(el), *ident),
                 ExprKind::Index(el, er, brackets_span) => {
                     hir::ExprKind::Index(self.lower_expr(el), self.lower_expr(er), *brackets_span)
                 }
@@ -312,7 +310,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         container,
                         ImplTraitContext::Disallowed(ImplTraitPosition::OffsetOf),
                     ),
-                    self.arena.alloc_from_iter(fields.iter().map(|&ident| self.lower_ident(ident))),
+                    self.arena.alloc_from_iter(fields.iter().copied()),
                 ),
                 ExprKind::Struct(se) => {
                     let rest = match &se.rest {
@@ -354,7 +352,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
             };
 
-            hir::Expr { hir_id, kind, span: self.lower_span(e.span) }
+            hir::Expr { hir_id, kind, span: e.span }
         })
     }
 
@@ -367,7 +365,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_binop(&mut self, b: BinOp) -> BinOp {
-        Spanned { node: b.node, span: self.lower_span(b.span) }
+        Spanned { node: b.node, span: b.span }
     }
 
     fn lower_legacy_const_generics(
@@ -405,7 +403,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let last_segment = path.segments.last_mut().unwrap();
         assert!(last_segment.args.is_none());
         last_segment.args = Some(AstP(GenericArgs::AngleBracketed(AngleBracketedArgs {
-            span: DUMMY_SP,
+            span: last_segment.span().shrink_to_hi(),
             args: generic_args,
         })));
 
@@ -503,8 +501,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let if_kind = hir::ExprKind::If(lowered_cond, self.arena.alloc(then), Some(else_expr));
         let if_expr = self.expr(span, if_kind);
         let block = self.block_expr(self.arena.alloc(if_expr));
-        let span = self.lower_span(span.with_hi(cond.span.hi()));
-        let opt_label = self.lower_label(opt_label);
+        let span = span.with_hi(cond.span.hi());
         hir::ExprKind::Loop(block, opt_label, hir::LoopSource::While, span)
     }
 
@@ -565,7 +562,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let pat = self.lower_pat(&arm.pat);
         let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond));
         let hir_id = self.next_id();
-        let span = self.lower_span(arm.span);
+        let span = arm.span;
         self.lower_attrs(hir_id, &arm.attrs);
         let is_never_pattern = pat.is_never_pattern();
         let body = if let Some(body) = &arm.body
@@ -637,7 +634,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // Resume argument type: `ResumeTy`
                 let unstable_span = self.mark_span_with_reason(
                     DesugaringKind::Async,
-                    self.lower_span(span),
+                    span,
                     Some(self.allow_gen_future.clone()),
                 );
                 let resume_ty =
@@ -655,12 +652,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     Ident::with_dummy_span(sym::_task_context),
                     hir::BindingMode::MUT,
                 );
-                let param = hir::Param {
-                    hir_id: self.next_id(),
-                    pat,
-                    ty_span: self.lower_span(span),
-                    span: self.lower_span(span),
-                };
+                let param = hir::Param { hir_id: self.next_id(), pat, ty_span: span, span };
                 let params = arena_vec![self; param];
 
                 (inputs, params, Some(task_context_hid))
@@ -668,8 +660,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir::CoroutineDesugaring::Gen => (&[], &[], None),
         };
 
-        let output =
-            return_ty.unwrap_or_else(|| hir::FnRetTy::DefaultReturn(self.lower_span(span)));
+        let output = return_ty.unwrap_or_else(|| hir::FnRetTy::DefaultReturn(span));
 
         let fn_decl = self.arena.alloc(hir::FnDecl {
             inputs,
@@ -702,7 +693,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             bound_generic_params: &[],
             fn_decl,
             body,
-            fn_decl_span: self.lower_span(fn_decl_span),
+            fn_decl_span,
             fn_arg_span: None,
             kind: hir::ClosureKind::Coroutine(coroutine_kind),
             constness: hir::Constness::NotConst,
@@ -753,20 +744,24 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ///     }
     /// }
     /// ```
-    fn lower_expr_await(&mut self, await_kw_span: Span, expr: &Expr) -> hir::ExprKind<'hir> {
+    fn lower_expr_await(
+        &mut self,
+        await_kw_span: Span,
+        full_span: Span,
+        expr: &Expr,
+    ) -> hir::ExprKind<'hir> {
         let expr = self.arena.alloc(self.lower_expr_mut(expr));
-        self.make_lowered_await(await_kw_span, expr, FutureKind::Future)
+        self.make_lowered_await(await_kw_span, full_span, expr, FutureKind::Future)
     }
 
     /// Takes an expr that has already been lowered and generates a desugared await loop around it
     fn make_lowered_await(
         &mut self,
         await_kw_span: Span,
+        full_span: Span,
         expr: &'hir hir::Expr<'hir>,
         await_kind: FutureKind,
     ) -> hir::ExprKind<'hir> {
-        let full_span = expr.span.to(await_kw_span);
-
         let is_async_gen = match self.coroutine_kind {
             Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::Async, _)) => false,
             Some(hir::CoroutineKind::Desugared(hir::CoroutineDesugaring::AsyncGen, _)) => true,
@@ -915,8 +910,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             };
 
             let lhs = self.expr_ident(span, task_context_ident, task_context_hid);
-            let assign =
-                self.expr(span, hir::ExprKind::Assign(lhs, yield_expr, self.lower_span(span)));
+            let assign = self.expr(span, hir::ExprKind::Assign(lhs, yield_expr, span));
             self.stmt_expr(span, assign)
         };
 
@@ -925,13 +919,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // loop { .. }
         let loop_expr = self.arena.alloc(hir::Expr {
             hir_id: loop_hir_id,
-            kind: hir::ExprKind::Loop(
-                loop_block,
-                None,
-                hir::LoopSource::Loop,
-                self.lower_span(span),
-            ),
-            span: self.lower_span(span),
+            kind: hir::ExprKind::Loop(loop_block, None, hir::LoopSource::Loop, span),
+            span,
         });
 
         // mut __awaitee => loop { ... }
@@ -1009,8 +998,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             bound_generic_params,
             fn_decl,
             body: body_id,
-            fn_decl_span: self.lower_span(fn_decl_span),
-            fn_arg_span: Some(self.lower_span(fn_arg_span)),
+            fn_decl_span,
+            fn_arg_span: Some(fn_arg_span),
             kind: closure_kind,
             constness: self.lower_constness(constness),
         });
@@ -1055,7 +1044,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let (binder, params) = match binder {
             ClosureBinder::NotPresent => (hir::ClosureBinder::Default, &[][..]),
             ClosureBinder::For { span, generic_params } => {
-                let span = self.lower_span(*span);
+                let span = *span;
                 (hir::ClosureBinder::For { span }, &**generic_params)
             }
         };
@@ -1124,8 +1113,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             bound_generic_params,
             fn_decl,
             body,
-            fn_decl_span: self.lower_span(fn_decl_span),
-            fn_arg_span: Some(self.lower_span(fn_arg_span)),
+            fn_decl_span,
+            fn_arg_span: Some(fn_arg_span),
             // Lower this as a `CoroutineClosure`. That will ensure that HIR typeck
             // knows that a `FnDecl` output type like `-> &str` actually means
             // "coroutine that returns &str", rather than directly returning a `&str`.
@@ -1166,11 +1155,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
         }
         if is_ordinary(self, lhs) {
-            return hir::ExprKind::Assign(
-                self.lower_expr(lhs),
-                self.lower_expr(rhs),
-                self.lower_span(eq_sign_span),
-            );
+            return hir::ExprKind::Assign(self.lower_expr(lhs), self.lower_expr(rhs), eq_sign_span);
         }
 
         let mut assignments = vec![];
@@ -1185,7 +1170,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             whole_span,
             Some(rhs),
             pat,
-            hir::LocalSource::AssignDesugar(self.lower_span(eq_sign_span)),
+            hir::LocalSource::AssignDesugar(eq_sign_span),
         );
 
         // `a = lhs1; b = lhs2;`.
@@ -1327,10 +1312,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let pat = self.destructure_assign(&f.expr, eq_sign_span, assignments);
                     hir::PatField {
                         hir_id: self.next_id(),
-                        ident: self.lower_ident(f.ident),
+                        ident: f.ident,
                         pat,
                         is_shorthand: f.is_shorthand,
-                        span: self.lower_span(f.span),
+                        span: f.span,
                     }
                 }));
                 let qpath = self.lower_qpath(
@@ -1374,11 +1359,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             _ => {}
         }
         // Treat all other cases as normal lvalue.
-        let ident = Ident::new(sym::lhs, self.lower_span(lhs.span));
+        let ident = Ident::new(sym::lhs, lhs.span);
         let (pat, binding) = self.pat_ident_mut(lhs.span, ident);
         let ident = self.expr_ident(lhs.span, ident, binding);
-        let assign =
-            hir::ExprKind::Assign(self.lower_expr(lhs), ident, self.lower_span(eq_sign_span));
+        let assign = hir::ExprKind::Assign(self.lower_expr(lhs), ident, eq_sign_span);
         let expr = self.expr(lhs.span, assign);
         assignments.push(self.stmt_expr(lhs.span, expr));
         pat
@@ -1418,7 +1402,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_expr_range_closed(&mut self, span: Span, e1: &Expr, e2: &Expr) -> hir::ExprKind<'hir> {
         let e1 = self.lower_expr_mut(e1);
         let e2 = self.lower_expr_mut(e2);
-        let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, self.lower_span(span));
+        let fn_path = hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, span);
         let fn_expr = self.arena.alloc(self.expr(span, hir::ExprKind::Path(fn_path)));
         hir::ExprKind::Call(fn_expr, arena_vec![self; e1, e2])
     }
@@ -1452,22 +1436,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
             e1.iter().map(|e| (sym::start, e)).chain(e2.iter().map(|e| (sym::end, e))).map(
                 |(s, e)| {
                     let expr = self.lower_expr(e);
-                    let ident = Ident::new(s, self.lower_span(e.span));
+                    let ident = Ident::new(s, e.span);
                     self.expr_field(ident, expr, e.span)
                 },
             ),
         );
 
-        hir::ExprKind::Struct(
-            self.arena.alloc(hir::QPath::LangItem(lang_item, self.lower_span(span))),
-            fields,
-            None,
-        )
-    }
-
-    fn lower_label(&self, opt_label: Option<Label>) -> Option<Label> {
-        let label = opt_label?;
-        Some(Label { ident: self.lower_ident(label.ident) })
+        hir::ExprKind::Struct(self.arena.alloc(hir::QPath::LangItem(lang_item, span)), fields, None)
     }
 
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
@@ -1484,7 +1459,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 .map(|id| Ok(self.lower_node_id(id)))
                 .unwrap_or(Err(hir::LoopIdError::OutsideLoopScope)),
         };
-        let label = self.lower_label(destination.map(|(_, label)| label));
+        let label = destination.map(|(_, label)| label);
         hir::Destination { label, target_id }
     }
 
@@ -1536,9 +1511,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.lower_attrs(hir_id, &f.attrs);
         hir::ExprField {
             hir_id,
-            ident: self.lower_ident(f.ident),
+            ident: f.ident,
             expr: self.lower_expr(&f.expr),
-            span: self.lower_span(f.span),
+            span: f.span,
             is_shorthand: f.is_shorthand,
         }
     }
@@ -1620,7 +1595,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let task_context_ident = Ident::with_dummy_span(sym::_task_context);
             let lhs = self.expr_ident(span, task_context_ident, task_context_hid);
 
-            hir::ExprKind::Assign(lhs, yield_expr, self.lower_span(span))
+            hir::ExprKind::Assign(lhs, yield_expr, span)
         } else {
             hir::ExprKind::Yield(yielded, hir::YieldSource::Yield)
         }
@@ -1653,8 +1628,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::Expr<'hir> {
         let head = self.lower_expr_mut(head);
         let pat = self.lower_pat(pat);
-        let for_span =
-            self.mark_span_with_reason(DesugaringKind::ForLoop, self.lower_span(e.span), None);
+        let for_span = self.mark_span_with_reason(DesugaringKind::ForLoop, e.span, None);
         let head_span = self.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
         let pat_span = self.mark_span_with_reason(DesugaringKind::ForLoop, pat.span, None);
 
@@ -1706,7 +1680,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     ));
                     // `unsafe { ... }`
                     let iter = self.arena.alloc(self.expr_unsafe(iter));
-                    let kind = self.make_lowered_await(head_span, iter, FutureKind::AsyncIterator);
+                    let kind = self.make_lowered_await(
+                        head_span,
+                        head_span,
+                        iter,
+                        FutureKind::AsyncIterator,
+                    );
                     self.arena.alloc(hir::Expr { hir_id: self.next_id(), kind, span: head_span })
                 }
             };
@@ -1722,9 +1701,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         // `[opt_ident]: loop { ... }`
         let kind = hir::ExprKind::Loop(
             loop_block,
-            self.lower_label(opt_label),
+            opt_label,
             hir::LoopSource::ForLoop,
-            self.lower_span(for_span.with_hi(head.span.hi())),
+            for_span.with_hi(head.span.hi()),
         );
         let loop_expr =
             self.arena.alloc(hir::Expr { hir_id: self.lower_node_id(e.id), kind, span: for_span });
@@ -2056,7 +2035,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn expr_lang_item_path(&mut self, span: Span, lang_item: hir::LangItem) -> hir::Expr<'hir> {
-        self.expr(span, hir::ExprKind::Path(hir::QPath::LangItem(lang_item, self.lower_span(span))))
+        self.expr(span, hir::ExprKind::Path(hir::QPath::LangItem(lang_item, span)))
     }
 
     /// `<LangItem>::name`
@@ -2066,7 +2045,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         lang_item: hir::LangItem,
         name: Symbol,
     ) -> hir::Expr<'hir> {
-        let qpath = self.make_lang_item_qpath(lang_item, self.lower_span(span), None);
+        let qpath = self.make_lang_item_qpath(lang_item, span, None);
         let path = hir::ExprKind::Path(hir::QPath::TypeRelative(
             self.arena.alloc(self.ty(span, hir::TyKind::Path(qpath))),
             self.arena.alloc(hir::PathSegment::new(
@@ -2098,7 +2077,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let expr_path = hir::ExprKind::Path(hir::QPath::Resolved(
             None,
             self.arena.alloc(hir::Path {
-                span: self.lower_span(span),
+                span,
                 res,
                 segments: arena_vec![self; hir::PathSegment::new(ident, hir_id, res)],
             }),
@@ -2118,7 +2097,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     expr: Some(expr),
                     hir_id,
                     rules: hir::BlockCheckMode::UnsafeBlock(hir::UnsafeSource::CompilerGenerated),
-                    span: self.lower_span(span),
+                    span,
                     targeted_by_break: false,
                 }),
                 None,
@@ -2151,7 +2130,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     pub(super) fn expr(&mut self, span: Span, kind: hir::ExprKind<'hir>) -> hir::Expr<'hir> {
         let hir_id = self.next_id();
-        hir::Expr { hir_id, kind, span: self.lower_span(span) }
+        hir::Expr { hir_id, kind, span }
     }
 
     pub(super) fn expr_field(
@@ -2160,13 +2139,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         expr: &'hir hir::Expr<'hir>,
         span: Span,
     ) -> hir::ExprField<'hir> {
-        hir::ExprField {
-            hir_id: self.next_id(),
-            ident,
-            span: self.lower_span(span),
-            expr,
-            is_shorthand: false,
-        }
+        hir::ExprField { hir_id: self.next_id(), ident, span, expr, is_shorthand: false }
     }
 
     pub(super) fn arm(
@@ -2174,13 +2147,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         pat: &'hir hir::Pat<'hir>,
         expr: &'hir hir::Expr<'hir>,
     ) -> hir::Arm<'hir> {
-        hir::Arm {
-            hir_id: self.next_id(),
-            pat,
-            guard: None,
-            span: self.lower_span(expr.span),
-            body: expr,
-        }
+        hir::Arm { hir_id: self.next_id(), pat, guard: None, span: expr.span, body: expr }
     }
 }
 
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 97fa90d340ea2..60fd4b9b0b00a 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -121,8 +121,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> &'hir hir::Mod<'hir> {
         self.arena.alloc(hir::Mod {
             spans: hir::ModSpans {
-                inner_span: self.lower_span(spans.inner_span),
-                inject_use_span: self.lower_span(spans.inject_use_span),
+                inner_span: spans.inner_span,
+                inject_use_span: spans.inject_use_span,
             },
             item_ids: self.arena.alloc_from_iter(items.iter().flat_map(|x| self.lower_item_ref(x))),
         })
@@ -153,17 +153,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
         let mut ident = i.ident;
-        let vis_span = self.lower_span(i.vis.span);
+        let vis_span = i.vis.span;
         let hir_id = self.lower_node_id(i.id);
         let attrs = self.lower_attrs(hir_id, &i.attrs);
         let kind = self.lower_item_kind(i.span, i.id, hir_id, &mut ident, attrs, vis_span, &i.kind);
-        let item = hir::Item {
-            owner_id: hir_id.expect_owner(),
-            ident: self.lower_ident(ident),
-            kind,
-            vis_span,
-            span: self.lower_span(i.span),
-        };
+        let item =
+            hir::Item { owner_id: hir_id.expect_owner(), ident, kind, vis_span, span: i.span };
         self.arena.alloc(item)
     }
 
@@ -229,7 +224,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let sig = hir::FnSig {
                         decl,
                         header: this.lower_fn_header(*header, hir::Safety::Safe),
-                        span: this.lower_span(*fn_sig_span),
+                        span: *fn_sig_span,
                     };
                     hir::ItemKind::Fn(sig, generics, body_id)
                 })
@@ -371,7 +366,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (defaultness, defaultness_span) = self.lower_defaultness(*defaultness, has_val);
                 let polarity = match polarity {
                     ImplPolarity::Positive => ImplPolarity::Positive,
-                    ImplPolarity::Negative(s) => ImplPolarity::Negative(self.lower_span(*s)),
+                    ImplPolarity::Negative(s) => ImplPolarity::Negative(*s),
                 };
                 hir::ItemKind::Impl(self.arena.alloc(hir::Impl {
                     constness: self.lower_constness(*constness),
@@ -548,10 +543,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                         let item = hir::Item {
                             owner_id: hir::OwnerId { def_id: new_hir_id },
-                            ident: this.lower_ident(ident),
+                            ident,
                             kind,
                             vis_span,
-                            span: this.lower_span(use_tree.span),
+                            span: use_tree.span,
                         };
                         hir::OwnerNode::Item(this.arena.alloc(item))
                     });
@@ -609,7 +604,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.lower_attrs(hir_id, &i.attrs);
         let item = hir::ForeignItem {
             owner_id,
-            ident: self.lower_ident(i.ident),
+            ident: i.ident,
             kind: match &i.kind {
                 ForeignItemKind::Fn(box Fn { sig, generics, .. }) => {
                     let fdec = &sig.decl;
@@ -633,7 +628,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let header = self.lower_fn_header(sig.header, hir::Safety::Unsafe);
 
                     hir::ForeignItemKind::Fn(
-                        hir::FnSig { header, decl, span: self.lower_span(sig.span) },
+                        hir::FnSig { header, decl, span: sig.span },
                         fn_args,
                         generics,
                     )
@@ -648,8 +643,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ForeignItemKind::TyAlias(..) => hir::ForeignItemKind::Type,
                 ForeignItemKind::MacCall(_) => panic!("macro shouldn't exist here"),
             },
-            vis_span: self.lower_span(i.vis.span),
-            span: self.lower_span(i.span),
+            vis_span: i.vis.span,
+            span: i.span,
         };
         self.arena.alloc(item)
     }
@@ -657,8 +652,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef {
         hir::ForeignItemRef {
             id: hir::ForeignItemId { owner_id: hir::OwnerId { def_id: self.local_def_id(i.id) } },
-            ident: self.lower_ident(i.ident),
-            span: self.lower_span(i.span),
+            ident: i.ident,
+            span: i.span,
         }
     }
 
@@ -670,8 +665,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             def_id: self.local_def_id(v.id),
             data: self.lower_variant_data(hir_id, &v.data),
             disr_expr: v.disr_expr.as_ref().map(|e| self.lower_anon_const_to_anon_const(e)),
-            ident: self.lower_ident(v.ident),
-            span: self.lower_span(v.span),
+            ident: v.ident,
+            span: v.span,
         }
     }
 
@@ -714,15 +709,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);
         hir::FieldDef {
-            span: self.lower_span(f.span),
+            span: f.span,
             hir_id,
             def_id: self.local_def_id(f.id),
             ident: match f.ident {
-                Some(ident) => self.lower_ident(ident),
+                Some(ident) => ident,
                 // FIXME(jseyfried): positional field hygiene.
-                None => Ident::new(sym::integer(index), self.lower_span(f.span)),
+                None => Ident::new(sym::integer(index), f.span),
             },
-            vis_span: self.lower_span(f.vis.span),
+            vis_span: f.vis.span,
             ty,
         }
     }
@@ -817,10 +812,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let item = hir::TraitItem {
             owner_id: trait_item_def_id,
-            ident: self.lower_ident(i.ident),
+            ident: i.ident,
             generics,
             kind,
-            span: self.lower_span(i.span),
+            span: i.span,
             defaultness: hir::Defaultness::Default { has_value: has_default },
         };
         self.arena.alloc(item)
@@ -841,12 +836,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
         };
         let id = hir::TraitItemId { owner_id: hir::OwnerId { def_id: self.local_def_id(i.id) } };
-        hir::TraitItemRef {
-            id,
-            ident: self.lower_ident(i.ident),
-            span: self.lower_span(i.span),
-            kind,
-        }
+        hir::TraitItemRef { id, ident: i.ident, span: i.span, kind }
     }
 
     /// Construct `ExprKind::Err` for the given `span`.
@@ -935,11 +925,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let item = hir::ImplItem {
             owner_id: hir_id.expect_owner(),
-            ident: self.lower_ident(i.ident),
+            ident: i.ident,
             generics,
             kind,
-            vis_span: self.lower_span(i.vis.span),
-            span: self.lower_span(i.span),
+            vis_span: i.vis.span,
+            span: i.span,
             defaultness,
         };
         self.arena.alloc(item)
@@ -948,8 +938,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
         hir::ImplItemRef {
             id: hir::ImplItemId { owner_id: hir::OwnerId { def_id: self.local_def_id(i.id) } },
-            ident: self.lower_ident(i.ident),
-            span: self.lower_span(i.span),
+            ident: i.ident,
+            span: i.span,
             kind: match &i.kind {
                 AssocItemKind::Const(..) => hir::AssocItemKind::Const,
                 AssocItemKind::Type(..) => hir::AssocItemKind::Type,
@@ -977,9 +967,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         has_value: bool,
     ) -> (hir::Defaultness, Option<Span>) {
         match d {
-            Defaultness::Default(sp) => {
-                (hir::Defaultness::Default { has_value }, Some(self.lower_span(sp)))
-            }
+            Defaultness::Default(sp) => (hir::Defaultness::Default { has_value }, Some(sp)),
             Defaultness::Final => {
                 assert!(has_value);
                 (hir::Defaultness::Final, None)
@@ -1018,8 +1006,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::Param {
             hir_id,
             pat: self.lower_pat(&param.pat),
-            ty_span: self.lower_span(param.ty.span),
-            span: self.lower_span(param.span),
+            ty_span: param.ty.span,
+            span: param.span,
         }
     }
 
@@ -1177,8 +1165,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let new_parameter = hir::Param {
                 hir_id: parameter.hir_id,
                 pat: new_parameter_pat,
-                ty_span: self.lower_span(parameter.ty_span),
-                span: self.lower_span(parameter.span),
+                ty_span: parameter.ty_span,
+                span: parameter.span,
             };
 
             if is_simple_parameter {
@@ -1290,7 +1278,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let expr = hir::Expr {
             hir_id: self.lower_node_id(closure_id),
             kind: coroutine_expr,
-            span: self.lower_span(body_span),
+            span: body_span,
         };
 
         (self.arena.alloc_from_iter(parameters), expr)
@@ -1309,7 +1297,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let (generics, decl) = self.lower_generics(generics, id, itctx, |this| {
             this.lower_fn_decl(&sig.decl, id, sig.span, kind, coroutine_kind)
         });
-        (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
+        (generics, hir::FnSig { header, decl, span: sig.span })
     }
 
     pub(super) fn lower_fn_header(
@@ -1486,8 +1474,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }));
 
         let has_where_clause_predicates = !generics.where_clause.predicates.is_empty();
-        let where_clause_span = self.lower_span(generics.where_clause.span);
-        let span = self.lower_span(generics.span);
+        let where_clause_span = generics.where_clause.span;
+        let span = generics.span;
         let res = f(self);
 
         let impl_trait_defs = std::mem::take(&mut self.impl_trait_defs);
@@ -1524,8 +1512,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
 
         let bounds = self.lower_param_bounds(bounds, itctx);
-
-        let ident = self.lower_ident(ident);
         let param_span = ident.span;
 
         // Reconstruct the span of the entire predicate from the individual generic bounds.
@@ -1536,7 +1522,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 None => span_accum,
             }
         });
-        let span = self.lower_span(span);
 
         match kind {
             GenericParamKind::Const { .. } => None,
@@ -1564,7 +1549,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }))
             }
             GenericParamKind::Lifetime => {
-                let ident = self.lower_ident(ident);
                 let lt_id = self.next_node_id();
                 let lifetime = self.new_named_lifetime(id, lt_id, ident);
                 Some(hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
@@ -1594,12 +1578,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     bounds,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Bound),
                 ),
-                span: self.lower_span(*span),
+                span: *span,
                 origin: PredicateOrigin::WhereClause,
             }),
             WherePredicate::RegionPredicate(WhereRegionPredicate { lifetime, bounds, span }) => {
                 hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
-                    span: self.lower_span(*span),
+                    span: *span,
                     lifetime: self.lower_lifetime(lifetime),
                     bounds: self.lower_param_bounds(
                         bounds,
@@ -1614,7 +1598,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         .lower_ty(lhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
                     rhs_ty: self
                         .lower_ty(rhs_ty, ImplTraitContext::Disallowed(ImplTraitPosition::Bound)),
-                    span: self.lower_span(*span),
+                    span: *span,
                 })
             }
         }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 34b8137aea8ef..ec26e89e18bd9 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -800,21 +800,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         })
     }
 
-    /// Intercept all spans entering HIR.
-    /// Mark a span as relative to the current owning item.
-    fn lower_span(&self, span: Span) -> Span {
-        if self.tcx.sess.opts.incremental.is_some() {
-            span.with_parent(Some(self.current_hir_id_owner.def_id))
-        } else {
-            // Do not make spans relative when not using incremental compilation.
-            span
-        }
-    }
-
-    fn lower_ident(&self, ident: Ident) -> Ident {
-        Ident::new(ident.name, self.lower_span(ident.span))
-    }
-
     /// Converts a lifetime into a new generic parameter.
     #[instrument(level = "debug", skip(self))]
     fn lifetime_res_to_generic_param(
@@ -853,7 +838,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id,
             def_id,
             name,
-            span: self.lower_span(ident.span),
+            span: ident.span,
             pure_wrt_drop: false,
             kind: hir::GenericParamKind::Lifetime { kind },
             colon_span: None,
@@ -948,7 +933,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             AttrKind::DocComment(comment_kind, data) => AttrKind::DocComment(comment_kind, data),
         };
 
-        Attribute { kind, id: attr.id, style: attr.style, span: self.lower_span(attr.span) }
+        Attribute { kind, id: attr.id, style: attr.style, span: attr.span }
     }
 
     fn alias_attrs(&mut self, id: HirId, target_id: HirId) {
@@ -1110,10 +1095,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         hir::AssocItemConstraint {
             hir_id: self.lower_node_id(constraint.id),
-            ident: self.lower_ident(constraint.ident),
+            ident: constraint.ident,
             gen_args,
             kind,
-            span: self.lower_span(constraint.span),
+            span: constraint.span,
         }
     }
 
@@ -1154,7 +1139,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     TyKind::Infer if self.tcx.features().generic_arg_infer() => {
                         return GenericArg::Infer(hir::InferArg {
                             hir_id: self.lower_node_id(ty.id),
-                            span: self.lower_span(ty.span),
+                            span: ty.span,
                         });
                     }
                     // We parse const arguments as path types as we cannot distinguish them during
@@ -1226,7 +1211,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 (bounds, lifetime_bound)
             });
             let kind = hir::TyKind::TraitObject(bounds, lifetime_bound, TraitObjectSyntax::None);
-            return hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.next_id() };
+            return hir::Ty { kind, span: t.span, hir_id: self.next_id() };
         }
 
         let id = self.lower_node_id(t.id);
@@ -1243,7 +1228,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     fn ty(&mut self, span: Span, kind: hir::TyKind<'hir>) -> hir::Ty<'hir> {
-        hir::Ty { hir_id: self.next_id(), kind, span: self.lower_span(span) }
+        hir::Ty { hir_id: self.next_id(), kind, span }
     }
 
     fn ty_tup(&mut self, span: Span, tys: &'hir [hir::Ty<'hir>]) -> hir::Ty<'hir> {
@@ -1287,7 +1272,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 });
                 let lifetime = self.lower_lifetime(&region);
                 let kind = hir::TyKind::Ref(lifetime, self.lower_mt(mt, itctx));
-                let span = self.lower_span(t.span);
+                let span = t.span;
                 let arg = hir::Ty { kind, span, hir_id: self.next_id() };
                 let args = self.arena.alloc(hir::GenericArgs {
                     args: self.arena.alloc([hir::GenericArg::Type(self.arena.alloc(arg))]),
@@ -1331,7 +1316,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             hir_id,
                             res
                         )],
-                        span: self.lower_span(t.span),
+                        span: t.span,
                     }),
                 ))
             }
@@ -1370,58 +1355,51 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 });
                 hir::TyKind::TraitObject(bounds, lifetime_bound, *kind)
             }
-            TyKind::ImplTrait(def_node_id, bounds) => {
-                let span = t.span;
-                match itctx {
-                    ImplTraitContext::OpaqueTy { origin } => {
-                        self.lower_opaque_impl_trait(span, origin, *def_node_id, bounds, itctx)
+            TyKind::ImplTrait(def_node_id, bounds) => match itctx {
+                ImplTraitContext::OpaqueTy { origin } => {
+                    self.lower_opaque_impl_trait(t.span, origin, *def_node_id, bounds, itctx)
+                }
+                ImplTraitContext::Universal => {
+                    if let Some(span) = bounds.iter().find_map(|bound| match *bound {
+                        ast::GenericBound::Use(_, span) => Some(span),
+                        _ => None,
+                    }) {
+                        self.tcx.dcx().emit_err(errors::NoPreciseCapturesOnApit { span });
                     }
-                    ImplTraitContext::Universal => {
-                        if let Some(span) = bounds.iter().find_map(|bound| match *bound {
-                            ast::GenericBound::Use(_, span) => Some(span),
-                            _ => None,
-                        }) {
-                            self.tcx.dcx().emit_err(errors::NoPreciseCapturesOnApit { span });
-                        }
 
-                        let def_id = self.local_def_id(*def_node_id);
-                        let name = self.tcx.item_name(def_id.to_def_id());
-                        let ident = Ident::new(name, span);
-                        let (param, bounds, path) = self.lower_universal_param_and_bounds(
-                            *def_node_id,
-                            span,
-                            ident,
-                            bounds,
-                        );
-                        self.impl_trait_defs.push(param);
-                        if let Some(bounds) = bounds {
-                            self.impl_trait_bounds.push(bounds);
-                        }
-                        path
-                    }
-                    ImplTraitContext::FeatureGated(position, feature) => {
-                        let guar = self
-                            .tcx
-                            .sess
-                            .create_feature_err(
-                                MisplacedImplTrait {
-                                    span: t.span,
-                                    position: DiagArgFromDisplay(&position),
-                                },
-                                feature,
-                            )
-                            .emit();
-                        hir::TyKind::Err(guar)
-                    }
-                    ImplTraitContext::Disallowed(position) => {
-                        let guar = self.dcx().emit_err(MisplacedImplTrait {
-                            span: t.span,
-                            position: DiagArgFromDisplay(&position),
-                        });
-                        hir::TyKind::Err(guar)
+                    let def_id = self.local_def_id(*def_node_id);
+                    let name = self.tcx.item_name(def_id.to_def_id());
+                    let ident = Ident::new(name, t.span);
+                    let (param, bounds, path) =
+                        self.lower_universal_param_and_bounds(*def_node_id, t.span, ident, bounds);
+                    self.impl_trait_defs.push(param);
+                    if let Some(bounds) = bounds {
+                        self.impl_trait_bounds.push(bounds);
                     }
+                    path
                 }
-            }
+                ImplTraitContext::FeatureGated(position, feature) => {
+                    let guar = self
+                        .tcx
+                        .sess
+                        .create_feature_err(
+                            MisplacedImplTrait {
+                                span: t.span,
+                                position: DiagArgFromDisplay(&position),
+                            },
+                            feature,
+                        )
+                        .emit();
+                    hir::TyKind::Err(guar)
+                }
+                ImplTraitContext::Disallowed(position) => {
+                    let guar = self.dcx().emit_err(MisplacedImplTrait {
+                        span: t.span,
+                        position: DiagArgFromDisplay(&position),
+                    });
+                    hir::TyKind::Err(guar)
+                }
+            },
             TyKind::Pat(ty, pat) => hir::TyKind::Pat(self.lower_ty(ty, itctx), self.lower_pat(pat)),
             TyKind::MacCall(_) => {
                 span_bug!(t.span, "`TyKind::MacCall` should have been expanded by now")
@@ -1436,7 +1414,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::Dummy => panic!("`TyKind::Dummy` should never be lowered"),
         };
 
-        hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.lower_node_id(t.id) }
+        hir::Ty { kind, span: t.span, hir_id: self.lower_node_id(t.id) }
     }
 
     /// Lowers a `ReturnPositionOpaqueTy` (`-> impl Trait`) or a `TypeAliasesOpaqueTy` (`type F =
@@ -1602,7 +1580,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     duplicated_lifetime_node_id,
                     lifetime.ident.name,
                     DefKind::LifetimeParam,
-                    self.lower_span(lifetime.ident.span),
+                    lifetime.ident.span,
                 );
                 captured_to_synthesized_mapping.insert(old_def_id, duplicated_lifetime_def_id);
                 // FIXME: Instead of doing this, we could move this whole loop
@@ -1611,7 +1589,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 synthesized_lifetime_definitions.push((
                     duplicated_lifetime_node_id,
                     duplicated_lifetime_def_id,
-                    self.lower_ident(lifetime.ident),
+                    lifetime.ident,
                     missing_kind,
                 ));
 
@@ -1669,13 +1647,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     params: generic_params,
                     predicates: &[],
                     has_where_clause_predicates: false,
-                    where_clause_span: this.lower_span(span),
-                    span: this.lower_span(span),
+                    where_clause_span: span,
+                    span,
                 }),
                 bounds,
                 origin,
                 lifetime_mapping,
-                span: this.lower_span(opaque_ty_span),
+                span: opaque_ty_span,
             };
             this.arena.alloc(opaque_ty_def)
         });
@@ -1710,7 +1688,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 });
                 hir::PreciseCapturingArg::Param(hir::PreciseCapturingNonLifetimeArg {
                     hir_id: self.lower_node_id(*id),
-                    ident: self.lower_ident(segment.ident),
+                    ident: segment.ident,
                     res: self.lower_res(res),
                 })
             }
@@ -1719,8 +1697,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     fn lower_fn_params_to_names(&mut self, decl: &FnDecl) -> &'hir [Ident] {
         self.arena.alloc_from_iter(decl.inputs.iter().map(|param| match param.pat.kind {
-            PatKind::Ident(_, ident, _) => self.lower_ident(ident),
-            _ => Ident::new(kw::Empty, self.lower_span(param.pat.span)),
+            PatKind::Ident(_, ident, _) => ident,
+            _ => Ident::new(kw::Empty, param.pat.span),
         }))
     }
 
@@ -1807,7 +1785,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     };
                     hir::FnRetTy::Return(self.lower_ty(ty, itctx))
                 }
-                FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(self.lower_span(*span)),
+                FnRetTy::Default(span) => hir::FnRetTy::DefaultReturn(*span),
             },
         };
 
@@ -1859,8 +1837,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         fn_kind: FnDeclKind,
         fn_span: Span,
     ) -> hir::FnRetTy<'hir> {
-        let span = self.lower_span(fn_span);
-
         let (opaque_ty_node_id, allowed_features) = match coro {
             CoroutineKind::Async { return_impl_trait_id, .. } => (return_impl_trait_id, None),
             CoroutineKind::Gen { return_impl_trait_id, .. } => (return_impl_trait_id, None),
@@ -1870,7 +1846,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         let opaque_ty_span =
-            self.mark_span_with_reason(DesugaringKind::Async, span, allowed_features);
+            self.mark_span_with_reason(DesugaringKind::Async, fn_span, allowed_features);
 
         let captured_lifetimes = self
             .resolver
@@ -1890,7 +1866,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             opaque_ty_node_id,
             hir::OpaqueTyOrigin::AsyncFn { parent: fn_def_id, in_trait_or_impl },
             captured_lifetimes,
-            span,
+            fn_span,
             opaque_ty_span,
             |this| {
                 let bound = this.lower_coroutine_fn_output_type_to_bound(
@@ -1967,16 +1943,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             GenericBound::Outlives(lifetime) => {
                 hir::GenericBound::Outlives(self.lower_lifetime(lifetime))
             }
-            GenericBound::Use(args, span) => hir::GenericBound::Use(
-                self.lower_precise_capturing_args(args),
-                self.lower_span(*span),
-            ),
+            GenericBound::Use(args, span) => {
+                hir::GenericBound::Use(self.lower_precise_capturing_args(args), *span)
+            }
         }
     }
 
     fn lower_lifetime(&mut self, l: &Lifetime) -> &'hir hir::Lifetime {
-        let ident = self.lower_ident(l.ident);
-        self.new_named_lifetime(l.id, l.id, ident)
+        self.new_named_lifetime(l.id, l.id, l.ident)
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -2005,11 +1979,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         debug!(?res);
-        self.arena.alloc(hir::Lifetime {
-            hir_id: self.lower_node_id(id),
-            ident: self.lower_ident(ident),
-            res,
-        })
+        self.arena.alloc(hir::Lifetime { hir_id: self.lower_node_id(id), ident, res })
     }
 
     #[instrument(level = "debug", skip(self))]
@@ -2053,10 +2023,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             hir_id,
             def_id: self.local_def_id(param.id),
             name,
-            span: self.lower_span(param.span()),
+            span: param.span(),
             pure_wrt_drop: attr::contains_name(&param.attrs, sym::may_dangle),
             kind,
-            colon_span: param.colon_span.map(|s| self.lower_span(s)),
+            colon_span: param.colon_span.map(|s| s),
             source,
         }
     }
@@ -2074,8 +2044,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     if let Some(LifetimeRes::Error) = self.resolver.get_lifetime_res(param.id) {
                         ParamName::Error
                     } else {
-                        let ident = self.lower_ident(param.ident);
-                        ParamName::Plain(ident)
+                        ParamName::Plain(param.ident)
                     };
                 let kind =
                     hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit };
@@ -2106,9 +2075,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 let kind = hir::GenericParamKind::Type { default, synthetic: false };
 
-                (hir::ParamName::Plain(self.lower_ident(param.ident)), kind)
+                (hir::ParamName::Plain(param.ident), kind)
             }
-            GenericParamKind::Const { ty, kw_span: _, default } => {
+            GenericParamKind::Const { ty, span: _, default } => {
                 let ty = self
                     .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::GenericDefault));
 
@@ -2128,10 +2097,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     })
                     .map(|def| self.lower_anon_const_to_const_arg(def));
 
-                (
-                    hir::ParamName::Plain(self.lower_ident(param.ident)),
-                    hir::GenericParamKind::Const { ty, default, synthetic: false },
-                )
+                (hir::ParamName::Plain(param.ident), hir::GenericParamKind::Const {
+                    ty,
+                    default,
+                    synthetic: false,
+                })
             }
         }
     }
@@ -2167,12 +2137,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.lower_lifetime_binder(p.trait_ref.ref_id, &p.bound_generic_params);
         let trait_ref = self.lower_trait_ref(p.modifiers, &p.trait_ref, itctx);
         let modifiers = self.lower_trait_bound_modifiers(p.modifiers);
-        hir::PolyTraitRef {
-            bound_generic_params,
-            modifiers,
-            trait_ref,
-            span: self.lower_span(p.span),
-        }
+        hir::PolyTraitRef { bound_generic_params, modifiers, trait_ref, span: p.span }
     }
 
     fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext) -> hir::MutTy<'hir> {
@@ -2206,13 +2171,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> (hir::GenericParam<'hir>, Option<hir::WherePredicate<'hir>>, hir::TyKind<'hir>) {
         // Add a definition for the in-band `Param`.
         let def_id = self.local_def_id(node_id);
-        let span = self.lower_span(span);
 
         // Set the name to `impl Bound1 + Bound2`.
         let param = hir::GenericParam {
             hir_id: self.lower_node_id(node_id),
             def_id,
-            name: ParamName::Plain(self.lower_ident(ident)),
+            name: ParamName::Plain(ident),
             pure_wrt_drop: false,
             span,
             kind: hir::GenericParamKind::Type { default: None, synthetic: true },
@@ -2238,8 +2202,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.arena.alloc(hir::Path {
                 span,
                 res,
-                segments:
-                    arena_vec![self; hir::PathSegment::new(self.lower_ident(ident), hir_id, res)],
+                segments: arena_vec![self; hir::PathSegment::new(ident, hir_id, res)],
             }),
         ));
 
@@ -2259,7 +2222,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 if self.tcx.features().generic_arg_infer() {
                     hir::ArrayLen::Infer(hir::InferArg {
                         hir_id: self.lower_node_id(c.id),
-                        span: self.lower_span(c.value.span),
+                        span: c.value.span,
                     })
                 } else {
                     feature_err(
@@ -2302,7 +2265,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                 let parent_def_id = self.current_def_id_parent;
                 let node_id = self.next_node_id();
-                let span = self.lower_span(span);
 
                 // Add a definition for the in-band const def.
                 let def_id =
@@ -2416,7 +2378,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 body: this.with_def_id_parent(def_id, |this| {
                     this.lower_const_body(c.value.span, Some(&c.value))
                 }),
-                span: this.lower_span(c.value.span),
+                span: c.value.span,
             }
         }))
     }
@@ -2438,7 +2400,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     // Helper methods for building HIR.
 
     fn stmt(&mut self, span: Span, kind: hir::StmtKind<'hir>) -> hir::Stmt<'hir> {
-        hir::Stmt { span: self.lower_span(span), kind, hir_id: self.next_id() }
+        hir::Stmt { span, kind, hir_id: self.next_id() }
     }
 
     fn stmt_expr(&mut self, span: Span, expr: hir::Expr<'hir>) -> hir::Stmt<'hir> {
@@ -2458,15 +2420,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             debug_assert!(!a.is_empty());
             self.attrs.insert(hir_id.local_id, a);
         }
-        let local = hir::LetStmt {
-            hir_id,
-            init,
-            pat,
-            els: None,
-            source,
-            span: self.lower_span(span),
-            ty: None,
-        };
+        let local = hir::LetStmt { hir_id, init, pat, els: None, source, span, ty: None };
         self.stmt(span, hir::StmtKind::Let(self.arena.alloc(local)))
     }
 
@@ -2485,7 +2439,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             expr,
             hir_id: self.next_id(),
             rules: hir::BlockCheckMode::DefaultBlock,
-            span: self.lower_span(span),
+            span,
             targeted_by_break: false,
         };
         self.arena.alloc(blk)
@@ -2517,10 +2471,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> &'hir [hir::PatField<'hir>] {
         let field = hir::PatField {
             hir_id: self.next_id(),
-            ident: Ident::new(sym::integer(0), self.lower_span(span)),
+            ident: Ident::new(sym::integer(0), span),
             is_shorthand: false,
             pat,
-            span: self.lower_span(span),
+            span,
         };
         arena_vec![self; field]
     }
@@ -2531,7 +2485,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         lang_item: hir::LangItem,
         fields: &'hir [hir::PatField<'hir>],
     ) -> &'hir hir::Pat<'hir> {
-        let qpath = hir::QPath::LangItem(lang_item, self.lower_span(span));
+        let qpath = hir::QPath::LangItem(lang_item, span);
         self.pat(span, hir::PatKind::Struct(qpath, fields, false))
     }
 
@@ -2564,8 +2518,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         (
             hir::Pat {
                 hir_id,
-                kind: hir::PatKind::Binding(bm, hir_id, self.lower_ident(ident), None),
-                span: self.lower_span(span),
+                kind: hir::PatKind::Binding(bm, hir_id, ident, None),
+                span,
                 default_binding_modes: true,
             },
             hir_id,
@@ -2576,18 +2530,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.arena.alloc(hir::Pat {
             hir_id: self.next_id(),
             kind,
-            span: self.lower_span(span),
+            span,
             default_binding_modes: true,
         })
     }
 
     fn pat_without_dbm(&mut self, span: Span, kind: hir::PatKind<'hir>) -> hir::Pat<'hir> {
-        hir::Pat {
-            hir_id: self.next_id(),
-            kind,
-            span: self.lower_span(span),
-            default_binding_modes: false,
-        }
+        hir::Pat { hir_id: self.next_id(), kind, span, default_binding_modes: false }
     }
 
     fn ty_path(&mut self, mut hir_id: HirId, span: Span, qpath: hir::QPath<'hir>) -> hir::Ty<'hir> {
@@ -2600,7 +2549,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             bound_generic_params: &[],
                             modifiers: hir::TraitBoundModifiers::NONE,
                             trait_ref: hir::TraitRef { path, hir_ref_id: hir_id },
-                            span: self.lower_span(span),
+                            span,
                         };
 
                         // The original ID is taken by the `PolyTraitRef`,
@@ -2618,7 +2567,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             _ => hir::TyKind::Path(qpath),
         };
 
-        hir::Ty { hir_id, kind, span: self.lower_span(span) }
+        hir::Ty { hir_id, kind, span }
     }
 
     /// Invoked to create the lifetime argument(s) for an elided trait object
@@ -2628,7 +2577,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn elided_dyn_bound(&mut self, span: Span) -> &'hir hir::Lifetime {
         let r = hir::Lifetime {
             hir_id: self.next_id(),
-            ident: Ident::new(kw::Empty, self.lower_span(span)),
+            ident: Ident::new(kw::Empty, span),
             res: hir::LifetimeName::ImplicitObjectLifetimeDefault,
         };
         debug!("elided_dyn_bound: r={:?}", r);
@@ -2656,7 +2605,7 @@ impl<'hir> GenericArgsCtor<'hir> {
             args: this.arena.alloc_from_iter(self.args),
             constraints: self.constraints,
             parenthesized: self.parenthesized,
-            span_ext: this.lower_span(self.span),
+            span_ext: self.span,
         };
         this.arena.alloc(ga)
     }
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index 760f84564f1a2..fa2e9b68ffde4 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -79,10 +79,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                             hir::PatField {
                                 hir_id,
-                                ident: self.lower_ident(f.ident),
+                                ident: f.ident,
                                 pat: self.lower_pat(&f.pat),
                                 is_shorthand: f.is_shorthand,
-                                span: self.lower_span(f.span),
+                                span: f.span,
                             }
                         }));
                         break hir::PatKind::Struct(qpath, fs, *etc == ast::PatFieldsRest::Rest);
@@ -261,7 +261,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 hir::PatKind::Binding(
                     annotation,
                     self.lower_node_id(canonical_id),
-                    self.lower_ident(ident),
+                    ident,
                     lower_sub(self),
                 )
             }
@@ -271,11 +271,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 hir::PatKind::Path(hir::QPath::Resolved(
                     None,
                     self.arena.alloc(hir::Path {
-                        span: self.lower_span(ident.span),
+                        span: ident.span,
                         res,
-                        segments: arena_vec![self; hir::PathSegment::new(self.lower_ident(ident), hir_id, res)],
+                        segments: arena_vec![self; hir::PathSegment::new(ident, hir_id, res)],
                     }),
-            ))
+                ))
             }
         }
     }
@@ -289,7 +289,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         hir::Pat {
             hir_id: self.lower_node_id(p.id),
             kind,
-            span: self.lower_span(p.span),
+            span: p.span,
             default_binding_modes: true,
         }
     }
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 258655de486f9..b2ce8153c1c51 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -126,11 +126,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     )
                 },
             )),
-            span: self.lower_span(
-                p.segments[..proj_start]
-                    .last()
-                    .map_or(path_span_lo, |segment| path_span_lo.to(segment.span())),
-            ),
+            span: p.segments[..proj_start]
+                .last()
+                .map_or(path_span_lo, |segment| path_span_lo.to(segment.span())),
         });
 
         if let Some(bound_modifier_allowed_features) = bound_modifier_allowed_features {
@@ -231,7 +229,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     None,
                 )
             })),
-            span: self.lower_span(p.span),
+            span: p.span,
         })
     }
 
@@ -382,7 +380,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         );
 
         hir::PathSegment {
-            ident: self.lower_ident(segment.ident),
+            ident: segment.ident,
             hir_id,
             res: self.lower_res(res),
             infer_args,
@@ -555,13 +553,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             parenthesized: hir::GenericArgsParentheses::No,
             span_ext: DUMMY_SP,
         });
-        hir::AssocItemConstraint {
-            hir_id: self.next_id(),
-            gen_args,
-            span: self.lower_span(span),
-            ident,
-            kind,
-        }
+        hir::AssocItemConstraint { hir_id: self.next_id(), gen_args, span, ident, kind }
     }
 
     /// When a bound is annotated with `async`, it signals to lowering that the trait
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 1d149e91b8513..53117e85b318c 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -826,11 +826,11 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara
                 }
                 GenericParamKind::Type { default: None } => (),
                 GenericParamKind::Lifetime => (),
-                GenericParamKind::Const { ty: _, kw_span: _, default: Some(default) } => {
+                GenericParamKind::Const { ty: _, span: _, default: Some(default) } => {
                     ordered_params += " = ";
                     ordered_params += &pprust::expr_to_string(&default.value);
                 }
-                GenericParamKind::Const { ty: _, kw_span: _, default: None } => (),
+                GenericParamKind::Const { ty: _, span: _, default: None } => (),
             }
             first = false;
         }
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index 82baaca9a4641..06156b2cc0a14 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -667,10 +667,10 @@ impl<'a> TraitDef<'a> {
 
                     cx.typaram(param.ident.span.with_ctxt(ctxt), param.ident, bounds, None)
                 }
-                GenericParamKind::Const { ty, kw_span, .. } => {
+                GenericParamKind::Const { ty, span, .. } => {
                     let const_nodefault_kind = GenericParamKind::Const {
                         ty: ty.clone(),
-                        kw_span: kw_span.with_ctxt(ctxt),
+                        span: span.with_ctxt(ctxt),
 
                         // We can't have default values inside impl block
                         default: None,
diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 2ede7d805fa40..c6d9f98ebc96d 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -511,6 +511,17 @@ impl MultiSpan {
     pub fn clone_ignoring_labels(&self) -> Self {
         Self { primary_spans: self.primary_spans.clone(), ..MultiSpan::new() }
     }
+
+    pub fn clone_ignoring_parents(&self) -> Self {
+        Self {
+            primary_spans: self.primary_spans.iter().map(|s| s.with_parent(None)).collect(),
+            span_labels: self
+                .span_labels
+                .iter()
+                .map(|(s, l)| (s.with_parent(None), l.clone()))
+                .collect(),
+        }
+    }
 }
 
 impl From<Span> for MultiSpan {
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 4352de3ad25fe..d3d2e155fb7db 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -403,19 +403,28 @@ impl DiagInner {
         &Level,
         &[(DiagMessage, Style)],
         &Option<ErrCode>,
-        &MultiSpan,
-        &[Subdiag],
-        &Suggestions,
+        MultiSpan,
+        Vec<Subdiag>,
+        Suggestions,
         Vec<(&DiagArgName, &DiagArgValue)>,
         &Option<IsLint>,
     ) {
+        let suggestions = match &self.suggestions {
+            Suggestions::Enabled(sugg) => Suggestions::Enabled(
+                sugg.iter().map(CodeSuggestion::clone_ignoring_parents).collect(),
+            ),
+            Suggestions::Sealed(sugg) => Suggestions::Sealed(
+                sugg.iter().map(CodeSuggestion::clone_ignoring_parents).collect(),
+            ),
+            Suggestions::Disabled => Suggestions::Disabled,
+        };
         (
             &self.level,
             &self.messages,
             &self.code,
-            &self.span,
-            &self.children,
-            &self.suggestions,
+            self.span.clone_ignoring_parents(),
+            self.children.iter().map(Subdiag::clone_ignoring_parents).collect(),
+            suggestions,
             self.args.iter().collect(),
             // omit self.sort_span
             &self.is_lint,
@@ -448,6 +457,13 @@ pub struct Subdiag {
     pub span: MultiSpan,
 }
 
+impl Subdiag {
+    fn clone_ignoring_parents(&self) -> Subdiag {
+        let Subdiag { level, messages, span } = self;
+        Subdiag { level: *level, messages: messages.clone(), span: span.clone_ignoring_parents() }
+    }
+}
+
 /// Used for emitting structured error messages and other diagnostic information.
 /// Wraps a `DiagInner`, adding some useful things.
 /// - The `dcx` field, allowing it to (a) emit itself, and (b) do a drop check
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 94365a89adc7e..cac89f3a0c8c1 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -233,9 +233,29 @@ impl SubstitutionPart {
         sm.span_to_snippet(self.span)
             .map_or(!self.span.is_empty(), |snippet| !snippet.trim().is_empty())
     }
+
+    fn clone_ignoring_parents(&self) -> SubstitutionPart {
+        let SubstitutionPart { span, snippet } = self;
+        SubstitutionPart { span: span.with_parent(None), snippet: snippet.clone() }
+    }
 }
 
 impl CodeSuggestion {
+    pub fn clone_ignoring_parents(&self) -> CodeSuggestion {
+        let CodeSuggestion { substitutions, msg, style, applicability } = self;
+        CodeSuggestion {
+            substitutions: substitutions
+                .iter()
+                .map(|Substitution { parts }| Substitution {
+                    parts: parts.iter().map(SubstitutionPart::clone_ignoring_parents).collect(),
+                })
+                .collect(),
+            msg: msg.clone(),
+            style: *style,
+            applicability: *applicability,
+        }
+    }
+
     /// Returns the assembled code suggestions, whether they should be shown with an underline
     /// and whether the substitution only differs in capitalization.
     pub(crate) fn splice_lines(
@@ -1533,6 +1553,7 @@ impl DiagCtxtInner {
                 let mut hasher = StableHasher::new();
                 diagnostic.hash(&mut hasher);
                 let diagnostic_hash = hasher.finish();
+                debug!(?diagnostic, ?diagnostic_hash);
                 !self.emitted_diagnostics.insert(diagnostic_hash)
             };
 
@@ -1542,18 +1563,14 @@ impl DiagCtxtInner {
             // Only emit the diagnostic if we've been asked to deduplicate or
             // haven't already emitted an equivalent diagnostic.
             if !(self.flags.deduplicate_diagnostics && already_emitted) {
-                debug!(?diagnostic);
-                debug!(?self.emitted_diagnostics);
-
                 let already_emitted_sub = |sub: &mut Subdiag| {
-                    debug!(?sub);
                     if sub.level != OnceNote && sub.level != OnceHelp {
                         return false;
                     }
                     let mut hasher = StableHasher::new();
                     sub.hash(&mut hasher);
                     let diagnostic_hash = hasher.finish();
-                    debug!(?diagnostic_hash);
+                    debug!(?sub, ?diagnostic_hash);
                     !self.emitted_diagnostics.insert(diagnostic_hash)
                 };
                 diagnostic.children.extract_if(already_emitted_sub).for_each(|_| {});
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 7e4bc508e5c77..9bf3395717bb4 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -999,7 +999,7 @@ pub trait ResolverExpand {
     fn visit_ast_fragment_with_placeholders(
         &mut self,
         expn_id: LocalExpnId,
-        fragment: &AstFragment,
+        fragment: &mut AstFragment,
     );
     fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind);
 
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index 5ffafcaa54262..51e4fd1090137 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -130,7 +130,7 @@ macro_rules! ast_fragments {
                 T::fragment_to_output(self)
             }
 
-            pub(crate) fn mut_visit_with<F: MutVisitor>(&mut self, vis: &mut F) {
+            pub fn mut_visit_with<F: MutVisitor>(&mut self, vis: &mut F) {
                 match self {
                     AstFragment::OptExpr(opt_expr) => {
                         visit_clobber(opt_expr, |opt_expr| {
@@ -602,7 +602,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         if self.monotonic {
             self.cx
                 .resolver
-                .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &fragment);
+                .visit_ast_fragment_with_placeholders(self.cx.current_expansion.id, &mut fragment);
 
             if self.cx.sess.opts.incremental.is_some() {
                 for (invoc, _) in invocations.iter_mut() {
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index eaf40a193a634..c732a95e1883f 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -776,9 +776,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 expected.only_has_type(self),
             );
         }
-        if let Some(span) =
-            tcx.resolutions(()).confused_type_with_std_module.get(&span.with_parent(None))
-        {
+        if let Some(span) = tcx.resolutions(()).confused_type_with_std_module.get(&span) {
             err.span_suggestion(
                 span.shrink_to_lo(),
                 "you are looking for the module in `std`, not the primitive type",
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index 5aebe716b0a10..dc56f56165d65 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -114,13 +114,18 @@ impl<'a> Parser<'a> {
 
         // Parse optional const generics default value.
         let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None };
+        let span = if let Some(ref default) = default {
+            const_span.to(default.value.span)
+        } else {
+            const_span.to(ty.span)
+        };
 
         Ok(GenericParam {
             ident,
             id: ast::DUMMY_NODE_ID,
             attrs: preceding_attrs,
             bounds: Vec::new(),
-            kind: GenericParamKind::Const { ty, kw_span: const_span, default },
+            kind: GenericParamKind::Const { ty, span, default },
             is_placeholder: false,
             colon_span: None,
         })
@@ -137,6 +142,11 @@ impl<'a> Parser<'a> {
 
         // Parse optional const generics default value.
         let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None };
+        let span = if let Some(ref default) = default {
+            mistyped_const_ident.span.to(default.value.span)
+        } else {
+            mistyped_const_ident.span.to(ty.span)
+        };
 
         self.dcx()
             .struct_span_err(
@@ -156,7 +166,7 @@ impl<'a> Parser<'a> {
             id: ast::DUMMY_NODE_ID,
             attrs: preceding_attrs,
             bounds: Vec::new(),
-            kind: GenericParamKind::Const { ty, kw_span: mistyped_const_ident.span, default },
+            kind: GenericParamKind::Const { ty, span, default },
             is_placeholder: false,
             colon_span: None,
         })
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 031ffaed808bd..552b0c72f1411 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -186,7 +186,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
     pub(crate) fn build_reduced_graph(
         &mut self,
-        fragment: &AstFragment,
+        fragment: &mut AstFragment,
         parent_scope: ParentScope<'ra>,
     ) -> MacroRulesScopeRef<'ra> {
         collect_definitions(self, fragment, parent_scope.expansion);
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 0047f2c4b51e9..044faceed5acd 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -1,8 +1,11 @@
 use std::mem;
 
-use rustc_ast::visit::FnKind;
+use rustc_ast::mut_visit::FnKind;
+use rustc_ast::ptr::P;
+use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
 use rustc_ast_pretty::pprust;
+use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_expand::expand::AstFragment;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind};
@@ -10,13 +13,14 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_span::Span;
 use rustc_span::hygiene::LocalExpnId;
 use rustc_span::symbol::{Symbol, kw, sym};
+use smallvec::{SmallVec, smallvec};
 use tracing::debug;
 
 use crate::{ImplTraitContext, InvocationParent, PendingAnonConstInfo, Resolver};
 
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,
-    fragment: &AstFragment,
+    fragment: &mut AstFragment,
     expansion: LocalExpnId,
 ) {
     let InvocationParent { parent_def, pending_anon_const_info, impl_trait_context, in_attr } =
@@ -29,7 +33,7 @@ pub(crate) fn collect_definitions(
         impl_trait_context,
         in_attr,
     };
-    fragment.visit_with(&mut visitor);
+    fragment.mut_visit_with(&mut visitor);
 }
 
 /// Creates `DefId`s for nodes in the AST.
@@ -73,23 +77,26 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
             .def_id()
     }
 
-    fn with_parent<F: FnOnce(&mut Self)>(&mut self, parent_def: LocalDefId, f: F) {
+    fn with_parent<R, F: FnOnce(&mut Self) -> R>(&mut self, parent_def: LocalDefId, f: F) -> R {
         let orig_parent_def = mem::replace(&mut self.parent_def, parent_def);
-        f(self);
+        let res = f(self);
         self.parent_def = orig_parent_def;
+        res
     }
 
-    fn with_impl_trait<F: FnOnce(&mut Self)>(
+    fn with_impl_trait<R, F: FnOnce(&mut Self) -> R>(
         &mut self,
         impl_trait_context: ImplTraitContext,
         f: F,
-    ) {
+    ) -> R {
         let orig_itc = mem::replace(&mut self.impl_trait_context, impl_trait_context);
-        f(self);
+        let res = f(self);
         self.impl_trait_context = orig_itc;
+        res
     }
 
-    fn collect_field(&mut self, field: &'a FieldDef, index: Option<usize>) {
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn collect_field(&mut self, field: FieldDef, index: Option<usize>) -> SmallVec<[FieldDef; 1]> {
         let index = |this: &Self| {
             index.unwrap_or_else(|| {
                 let node_id = NodeId::placeholder_from_expn_id(this.expansion);
@@ -101,13 +108,15 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
             let old_index = self.resolver.placeholder_field_indices.insert(field.id, index(self));
             assert!(old_index.is_none(), "placeholder field index is reset for a node ID");
             self.visit_macro_invoc(field.id);
+            return smallvec![field];
         } else {
             let name = field.ident.map_or_else(|| sym::integer(index(self)), |ident| ident.name);
             let def = self.create_def(field.id, name, DefKind::Field, field.span);
-            self.with_parent(def, |this| visit::walk_field_def(this, field));
+            self.with_parent(def, |this| mut_visit::walk_flat_map_field_def(this, field))
         }
     }
 
+    #[tracing::instrument(level = "trace", skip(self))]
     fn visit_macro_invoc(&mut self, id: NodeId) {
         let id = id.placeholder_to_expn_id();
         let pending_anon_const_info = self.pending_anon_const_info.take();
@@ -129,17 +138,14 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
     fn is_const_arg_trivial_macro_expansion(
         &self,
         anon_const: &'a AnonConst,
-    ) -> Option<(PendingAnonConstInfo, NodeId)> {
+    ) -> Option<PendingAnonConstInfo> {
         let (block_was_stripped, expr) = anon_const.value.maybe_unwrap_block();
         match expr {
-            Expr { kind: ExprKind::MacCall(..), id, .. } => Some((
-                PendingAnonConstInfo {
-                    id: anon_const.id,
-                    span: anon_const.value.span,
-                    block_was_stripped,
-                },
-                *id,
-            )),
+            Expr { kind: ExprKind::MacCall(..), .. } => Some(PendingAnonConstInfo {
+                id: anon_const.id,
+                span: anon_const.value.span,
+                block_was_stripped,
+            }),
             _ => None,
         }
     }
@@ -176,8 +182,15 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
     }
 }
 
-impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
-    fn visit_item(&mut self, i: &'a Item) {
+impl<'a, 'ra, 'tcx> mut_visit::MutVisitor for DefCollector<'a, 'ra, 'tcx> {
+    fn visit_span(&mut self, span: &mut Span) {
+        if self.resolver.tcx.sess.opts.incremental.is_some() {
+            *span = span.with_parent(Some(self.parent_def));
+        }
+    }
+
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn flat_map_item(&mut self, mut i: P<Item>) -> SmallVec<[P<Item>; 1]> {
         // Pick the def data. This need not be unique, but the more
         // information we encapsulate into, the better
         let mut opt_macro_data = None;
@@ -200,15 +213,16 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             ItemKind::Const(..) => DefKind::Const,
             ItemKind::Fn(..) | ItemKind::Delegation(..) => DefKind::Fn,
             ItemKind::MacroDef(..) => {
-                let macro_data = self.resolver.compile_macro(i, self.resolver.tcx.sess.edition());
+                let macro_data = self.resolver.compile_macro(&i, self.resolver.tcx.sess.edition());
                 let macro_kind = macro_data.ext.macro_kind();
                 opt_macro_data = Some(macro_data);
                 DefKind::Macro(macro_kind)
             }
             ItemKind::GlobalAsm(..) => DefKind::GlobalAsm,
-            ItemKind::Use(..) => return visit::walk_item(self, i),
+            ItemKind::Use(..) => DefKind::Use,
             ItemKind::MacCall(..) | ItemKind::DelegationMac(..) => {
-                return self.visit_macro_invoc(i.id);
+                self.visit_macro_invoc(i.id);
+                return smallvec![i];
             }
         };
         let def_id = self.create_def(i.id, i.ident.name, def_kind, i.span);
@@ -219,7 +233,8 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
 
         self.with_parent(def_id, |this| {
             this.with_impl_trait(ImplTraitContext::Existential, |this| {
-                match i.kind {
+                let item = &mut *i;
+                match &mut item.kind {
                     ItemKind::Struct(ref struct_def, _) | ItemKind::Union(ref struct_def, _) => {
                         // If this is a unit or tuple-like struct, register the constructor.
                         if let Some((ctor_kind, ctor_node_id)) = CtorKind::from_ast(struct_def) {
@@ -227,71 +242,107 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                                 ctor_node_id,
                                 kw::Empty,
                                 DefKind::Ctor(CtorOf::Struct, ctor_kind),
-                                i.span,
+                                item.span,
                             );
                         }
                     }
                     _ => {}
                 }
-                visit::walk_item(this, i);
+                mut_visit::walk_flat_map_item(this, i)
             })
-        });
+        })
     }
 
-    fn visit_fn(&mut self, fn_kind: FnKind<'a>, span: Span, _: NodeId) {
-        match fn_kind {
-            FnKind::Fn(_ctxt, _ident, FnSig { header, decl, span: _ }, _vis, generics, body)
-                if let Some(coroutine_kind) = header.coroutine_kind =>
-            {
+    fn visit_fn(&mut self, mut fn_kind: FnKind<'_>, fn_span: Span, _: NodeId) {
+        match &mut fn_kind {
+            FnKind::Fn(FnSig { header, decl, span }, ref mut generics, ref mut body) => {
+                // Identifier and visibility are visited as a part of the item.
                 self.visit_fn_header(header);
                 self.visit_generics(generics);
 
                 // For async functions, we need to create their inner defs inside of a
                 // closure to match their desugared representation. Besides that,
                 // we must mirror everything that `visit::walk_fn` below does.
-                let FnDecl { inputs, output } = &**decl;
-                for param in inputs {
-                    self.visit_param(param);
-                }
-
-                let (return_id, return_span) = coroutine_kind.return_id();
-                let return_def =
-                    self.create_def(return_id, kw::Empty, DefKind::OpaqueTy, return_span);
-                self.with_parent(return_def, |this| this.visit_fn_ret_ty(output));
+                let FnDecl { inputs, output } = &mut **decl;
+                inputs.flat_map_in_place(|param| self.flat_map_param(param));
+
+                let return_def = if let Some(coroutine_kind) = header.coroutine_kind {
+                    let (return_id, return_span) = coroutine_kind.return_id();
+                    self.create_def(return_id, kw::Empty, DefKind::OpaqueTy, return_span)
+                } else {
+                    self.parent_def
+                };
+                self.with_parent(return_def, |this| mut_visit::walk_fn_ret_ty(this, output));
 
                 // If this async fn has no body (i.e. it's an async fn signature in a trait)
                 // then the closure_def will never be used, and we should avoid generating a
                 // def-id for it.
                 if let Some(body) = body {
-                    let closure_def = self.create_def(
-                        coroutine_kind.closure_id(),
-                        kw::Empty,
-                        DefKind::Closure,
-                        span,
-                    );
+                    let closure_def = if let Some(coroutine_kind) = header.coroutine_kind {
+                        self.create_def(
+                            coroutine_kind.closure_id(),
+                            kw::Empty,
+                            DefKind::Closure,
+                            fn_span,
+                        )
+                    } else {
+                        self.parent_def
+                    };
                     self.with_parent(closure_def, |this| this.visit_block(body));
                 }
+                self.visit_span(span);
             }
-            FnKind::Closure(binder, Some(coroutine_kind), decl, body) => {
+            FnKind::Closure(binder, coroutine_kind, decl, body) => {
                 self.visit_closure_binder(binder);
-                visit::walk_fn_decl(self, decl);
+                self.visit_fn_decl(decl);
 
                 // Async closures desugar to closures inside of closures, so
                 // we must create two defs.
-                let coroutine_def =
-                    self.create_def(coroutine_kind.closure_id(), kw::Empty, DefKind::Closure, span);
-                self.with_parent(coroutine_def, |this| this.visit_expr(body));
+                let closure_def = if let Some(coroutine_kind) = coroutine_kind {
+                    self.create_def(
+                        coroutine_kind.closure_id(),
+                        kw::Empty,
+                        DefKind::Closure,
+                        fn_span,
+                    )
+                } else {
+                    self.parent_def
+                };
+                self.with_parent(closure_def, |this| this.visit_expr(body));
             }
-            _ => visit::walk_fn(self, fn_kind),
         }
     }
 
-    fn visit_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId, _nested: bool) {
-        self.create_def(id, kw::Empty, DefKind::Use, use_tree.span);
-        visit::walk_use_tree(self, use_tree, id);
+    fn visit_use_tree(&mut self, use_tree: &mut UseTree) {
+        let UseTree { prefix, kind, span } = use_tree;
+        self.visit_path(prefix);
+        match kind {
+            UseTreeKind::Simple(None) => {}
+            UseTreeKind::Simple(Some(rename)) => self.visit_ident(rename),
+            UseTreeKind::Nested { items, span } => {
+                for (tree, id) in items {
+                    self.visit_id(id);
+                    // HIR lowers use trees as a flat stream of `ItemKind::Use`.
+                    // This means all the def-ids must be parented to the module,
+                    // and not to `self.parent_def` which is the topmost `use` item.
+                    self.resolver.create_def(
+                        self.resolver.tcx.local_parent(self.parent_def),
+                        *id,
+                        kw::Empty,
+                        DefKind::Use,
+                        self.expansion.to_expn_id(),
+                        span.with_parent(None),
+                    );
+                    self.visit_use_tree(tree);
+                }
+                self.visit_span(span);
+            }
+            UseTreeKind::Glob => {}
+        }
+        self.visit_span(span);
     }
 
-    fn visit_foreign_item(&mut self, fi: &'a ForeignItem) {
+    fn flat_map_foreign_item(&mut self, fi: P<ForeignItem>) -> SmallVec<[P<ForeignItem>; 1]> {
         let def_kind = match fi.kind {
             ForeignItemKind::Static(box StaticItem { ty: _, mutability, expr: _, safety }) => {
                 let safety = match safety {
@@ -303,17 +354,21 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             }
             ForeignItemKind::Fn(_) => DefKind::Fn,
             ForeignItemKind::TyAlias(_) => DefKind::ForeignTy,
-            ForeignItemKind::MacCall(_) => return self.visit_macro_invoc(fi.id),
+            ForeignItemKind::MacCall(_) => {
+                self.visit_macro_invoc(fi.id);
+                return smallvec![fi];
+            }
         };
 
         let def = self.create_def(fi.id, fi.ident.name, def_kind, fi.span);
 
-        self.with_parent(def, |this| visit::walk_item(this, fi));
+        self.with_parent(def, |this| mut_visit::walk_flat_map_item(this, fi))
     }
 
-    fn visit_variant(&mut self, v: &'a Variant) {
+    fn flat_map_variant(&mut self, v: Variant) -> SmallVec<[Variant; 1]> {
         if v.is_placeholder {
-            return self.visit_macro_invoc(v.id);
+            self.visit_macro_invoc(v.id);
+            return smallvec![v];
         }
         let def = self.create_def(v.id, v.ident.name, DefKind::Variant, v.span);
         self.with_parent(def, |this| {
@@ -325,23 +380,37 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     v.span,
                 );
             }
-            visit::walk_variant(this, v)
-        });
+            mut_visit::walk_flat_map_variant(this, v)
+        })
     }
 
-    fn visit_variant_data(&mut self, data: &'a VariantData) {
+    fn visit_variant_data(&mut self, data: &mut VariantData) {
         // The assumption here is that non-`cfg` macro expansion cannot change field indices.
         // It currently holds because only inert attributes are accepted on fields,
         // and every such attribute expands into a single field after it's resolved.
-        for (index, field) in data.fields().iter().enumerate() {
-            self.collect_field(field, Some(index));
-        }
+        let fields = match data {
+            VariantData::Struct { fields, recovered: _ } => fields,
+            VariantData::Tuple(fields, id) => {
+                self.visit_id(id);
+                fields
+            }
+            VariantData::Unit(id) => {
+                self.visit_id(id);
+                return;
+            }
+        };
+        let mut index = 0;
+        fields.flat_map_in_place(|field| {
+            let field = self.collect_field(field, Some(index));
+            index = index + 1;
+            field
+        })
     }
 
-    fn visit_generic_param(&mut self, param: &'a GenericParam) {
+    fn flat_map_generic_param(&mut self, param: GenericParam) -> SmallVec<[GenericParam; 1]> {
         if param.is_placeholder {
             self.visit_macro_invoc(param.id);
-            return;
+            return smallvec![param];
         }
         let def_kind = match param.kind {
             GenericParamKind::Lifetime { .. } => DefKind::LifetimeParam,
@@ -357,32 +426,38 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         //
         // In that case, the impl-trait is lowered as an additional generic parameter.
         self.with_impl_trait(ImplTraitContext::Universal, |this| {
-            visit::walk_generic_param(this, param)
-        });
+            mut_visit::walk_flat_map_generic_param(this, param)
+        })
     }
 
-    fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) {
+    fn flat_map_assoc_item(
+        &mut self,
+        i: P<AssocItem>,
+        _: AssocCtxt,
+    ) -> SmallVec<[P<AssocItem>; 1]> {
         let def_kind = match &i.kind {
             AssocItemKind::Fn(..) | AssocItemKind::Delegation(..) => DefKind::AssocFn,
             AssocItemKind::Const(..) => DefKind::AssocConst,
             AssocItemKind::Type(..) => DefKind::AssocTy,
             AssocItemKind::MacCall(..) | AssocItemKind::DelegationMac(..) => {
-                return self.visit_macro_invoc(i.id);
+                self.visit_macro_invoc(i.id);
+                return smallvec![i];
             }
         };
 
-        let def = self.create_def(i.id, i.ident.name, def_kind, i.span);
-        self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt));
+        let span = i.span;
+        let def = self.create_def(i.id, i.ident.name, def_kind, span);
+        self.with_parent(def, |this| mut_visit::walk_flat_map_item(this, i))
     }
 
-    fn visit_pat(&mut self, pat: &'a Pat) {
-        match pat.kind {
-            PatKind::MacCall(..) => self.visit_macro_invoc(pat.id),
-            _ => visit::walk_pat(self, pat),
+    fn visit_pat(&mut self, pat: &mut P<Pat>) {
+        if let PatKind::MacCall(..) = pat.kind {
+            return self.visit_macro_invoc(pat.id);
         }
+        mut_visit::walk_pat(self, pat)
     }
 
-    fn visit_anon_const(&mut self, constant: &'a AnonConst) {
+    fn visit_anon_const(&mut self, constant: &mut AnonConst) {
         // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
         // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
         // may accidentally identify a construction of a unit struct as a param and not create a
@@ -390,20 +465,18 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         // items will be messed up, but that's ok because there can't be any if we're just looking
         // for bare idents.
 
-        if let Some((pending_anon, macro_invoc)) =
-            self.is_const_arg_trivial_macro_expansion(constant)
-        {
+        if let Some(pending_anon) = self.is_const_arg_trivial_macro_expansion(constant) {
             self.pending_anon_const_info = Some(pending_anon);
-            return self.visit_macro_invoc(macro_invoc);
+            return mut_visit::walk_anon_const(self, constant);
         } else if constant.value.is_potential_trivial_const_arg(true) {
-            return visit::walk_anon_const(self, constant);
+            return mut_visit::walk_anon_const(self, constant);
         }
 
         let def = self.create_def(constant.id, kw::Empty, DefKind::AnonConst, constant.value.span);
-        self.with_parent(def, |this| visit::walk_anon_const(this, constant));
+        self.with_parent(def, |this| mut_visit::walk_anon_const(this, constant));
     }
 
-    fn visit_expr(&mut self, expr: &'a Expr) {
+    fn visit_expr(&mut self, expr: &mut P<Expr>) {
         // If we're visiting the expression of a const argument that was a macro call then
         // check if it is *still* unknown whether it is a trivial const arg or not. If so
         // recurse into the macro call and delay creating the anon const def until expansion.
@@ -431,33 +504,34 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             })
             .unwrap_or(self.parent_def);
 
+        let expr = &mut **expr;
         self.with_parent(parent_def, |this| {
             let parent_def = match expr.kind {
                 ExprKind::MacCall(..) => return this.visit_macro_invoc(expr.id),
                 ExprKind::Closure(..) | ExprKind::Gen(..) => {
                     this.create_def(expr.id, kw::Empty, DefKind::Closure, expr.span)
                 }
-                ExprKind::ConstBlock(ref constant) => {
-                    for attr in &expr.attrs {
-                        visit::walk_attribute(this, attr);
-                    }
+                ExprKind::ConstBlock(ref mut constant) => {
+                    mut_visit::visit_attrs(this, &mut expr.attrs);
                     let def = this.create_def(
                         constant.id,
                         kw::Empty,
                         DefKind::InlineConst,
                         constant.value.span,
                     );
-                    this.with_parent(def, |this| visit::walk_anon_const(this, constant));
+                    this.with_parent(def, |this| mut_visit::walk_anon_const(this, constant));
+                    this.visit_span(&mut expr.span);
                     return;
                 }
                 _ => this.parent_def,
             };
 
-            this.with_parent(parent_def, |this| visit::walk_expr(this, expr))
+            this.with_parent(parent_def, |this| mut_visit::walk_expr(this, expr))
         })
     }
 
-    fn visit_ty(&mut self, ty: &'a Ty) {
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn visit_ty(&mut self, ty: &mut P<Ty>) {
         match &ty.kind {
             TyKind::MacCall(..) => self.visit_macro_invoc(ty.id),
             TyKind::ImplTrait(id, _) => {
@@ -474,68 +548,74 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                 match self.impl_trait_context {
                     // Do not nest APIT, as we desugar them as `impl_trait: bounds`,
                     // so the `impl_trait` node is not a parent to `bounds`.
-                    ImplTraitContext::Universal => visit::walk_ty(self, ty),
+                    ImplTraitContext::Universal => mut_visit::walk_ty(self, ty),
                     ImplTraitContext::Existential => {
-                        self.with_parent(id, |this| visit::walk_ty(this, ty))
+                        self.with_parent(id, |this| mut_visit::walk_ty(this, ty))
                     }
                 };
             }
-            _ => visit::walk_ty(self, ty),
+            _ => mut_visit::walk_ty(self, ty),
         }
     }
 
-    fn visit_stmt(&mut self, stmt: &'a Stmt) {
-        match stmt.kind {
-            StmtKind::MacCall(..) => self.visit_macro_invoc(stmt.id),
-            _ => visit::walk_stmt(self, stmt),
+    fn flat_map_stmt(&mut self, stmt: Stmt) -> SmallVec<[Stmt; 1]> {
+        if let StmtKind::MacCall(..) = stmt.kind {
+            self.visit_macro_invoc(stmt.id);
+            return smallvec![stmt];
         }
+        mut_visit::walk_flat_map_stmt(self, stmt)
     }
 
-    fn visit_arm(&mut self, arm: &'a Arm) {
-        if arm.is_placeholder { self.visit_macro_invoc(arm.id) } else { visit::walk_arm(self, arm) }
+    fn flat_map_arm(&mut self, arm: Arm) -> SmallVec<[Arm; 1]> {
+        if arm.is_placeholder {
+            self.visit_macro_invoc(arm.id);
+            return smallvec![arm];
+        }
+        mut_visit::walk_flat_map_arm(self, arm)
     }
 
-    fn visit_expr_field(&mut self, f: &'a ExprField) {
+    fn flat_map_expr_field(&mut self, f: ExprField) -> SmallVec<[ExprField; 1]> {
         if f.is_placeholder {
-            self.visit_macro_invoc(f.id)
-        } else {
-            visit::walk_expr_field(self, f)
+            self.visit_macro_invoc(f.id);
+            return smallvec![f];
         }
+        mut_visit::walk_flat_map_expr_field(self, f)
     }
 
-    fn visit_pat_field(&mut self, fp: &'a PatField) {
+    fn flat_map_pat_field(&mut self, fp: PatField) -> SmallVec<[PatField; 1]> {
         if fp.is_placeholder {
-            self.visit_macro_invoc(fp.id)
-        } else {
-            visit::walk_pat_field(self, fp)
+            self.visit_macro_invoc(fp.id);
+            return smallvec![fp];
         }
+        mut_visit::walk_flat_map_pat_field(self, fp)
     }
 
-    fn visit_param(&mut self, p: &'a Param) {
+    fn flat_map_param(&mut self, p: Param) -> SmallVec<[Param; 1]> {
         if p.is_placeholder {
-            self.visit_macro_invoc(p.id)
-        } else {
-            self.with_impl_trait(ImplTraitContext::Universal, |this| visit::walk_param(this, p))
+            self.visit_macro_invoc(p.id);
+            return smallvec![p];
         }
+        self.with_impl_trait(ImplTraitContext::Universal, |this| {
+            mut_visit::walk_flat_map_param(this, p)
+        })
     }
 
     // This method is called only when we are visiting an individual field
     // after expanding an attribute on it.
-    fn visit_field_def(&mut self, field: &'a FieldDef) {
-        self.collect_field(field, None);
+    fn flat_map_field_def(&mut self, field: FieldDef) -> SmallVec<[FieldDef; 1]> {
+        self.collect_field(field, None)
     }
 
-    fn visit_crate(&mut self, krate: &'a Crate) {
+    fn visit_crate(&mut self, krate: &mut Crate) {
         if krate.is_placeholder {
-            self.visit_macro_invoc(krate.id)
-        } else {
-            visit::walk_crate(self, krate)
+            return self.visit_macro_invoc(krate.id);
         }
+        mut_visit::walk_crate(self, krate)
     }
 
-    fn visit_attribute(&mut self, attr: &'a Attribute) -> Self::Result {
+    fn visit_attribute(&mut self, attr: &mut Attribute) {
         let orig_in_attr = mem::replace(&mut self.in_attr, true);
-        visit::walk_attribute(self, attr);
+        mut_visit::walk_attribute(self, attr);
         self.in_attr = orig_in_attr;
     }
 }
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index adb0ba7c82036..f53198cb6f966 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -1552,7 +1552,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                             .bindings
                             .remove(&Ident::with_dummy_span(param.ident.name));
                     }
-                    GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
+                    GenericParamKind::Const { ref ty, span: _, ref default } => {
                         // Const parameters can't have param bounds.
                         assert!(param.bounds.is_empty());
 
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index f0632a21091bb..73b2563092a0a 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -2564,7 +2564,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                         let span = if let [.., bound] = &param.bounds[..] {
                             bound.span()
                         } else if let GenericParam {
-                            kind: GenericParamKind::Const { ty, kw_span: _, default  }, ..
+                            kind: GenericParamKind::Const { ty, span: _, default  }, ..
                         } = param {
                             default.as_ref().map(|def| def.value.span).unwrap_or(ty.span)
                         } else {
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index a9ebffea8a10b..760d259679d7b 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -199,7 +199,7 @@ impl<'ra, 'tcx> ResolverExpand for Resolver<'ra, 'tcx> {
     fn visit_ast_fragment_with_placeholders(
         &mut self,
         expansion: LocalExpnId,
-        fragment: &AstFragment,
+        fragment: &mut AstFragment,
     ) {
         // Integrate the new AST fragment into all the definition and module structures.
         // We are inside the `expansion` now, but other parent scope components are still the same.
diff --git a/compiler/rustc_serialize/src/int_overflow.rs b/compiler/rustc_serialize/src/int_overflow.rs
index f2aac2ef711c1..2e65e8dc80707 100644
--- a/compiler/rustc_serialize/src/int_overflow.rs
+++ b/compiler/rustc_serialize/src/int_overflow.rs
@@ -20,6 +20,7 @@ macro_rules! impl_debug_strict_add {
     ($( $ty:ty )*) => {
         $(
             impl DebugStrictAdd for $ty {
+                #[inline(always)]
                 fn debug_strict_add(self, other: Self) -> Self {
                     if cfg!(debug_assertions) {
                         self + other
@@ -42,6 +43,7 @@ macro_rules! impl_debug_strict_sub {
     ($( $ty:ty )*) => {
         $(
             impl DebugStrictSub for $ty {
+                #[inline(always)]
                 fn debug_strict_sub(self, other: Self) -> Self {
                     if cfg!(debug_assertions) {
                         self - other
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils.rs b/src/tools/clippy/clippy_utils/src/ast_utils.rs
index 0be6dc15a8e13..711832f78bbd6 100644
--- a/src/tools/clippy/clippy_utils/src/ast_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/ast_utils.rs
@@ -804,13 +804,13 @@ pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
             (
                 Const {
                     ty: lt,
-                    kw_span: _,
                     default: ld,
+                    span: _,
                 },
                 Const {
                     ty: rt,
-                    kw_span: _,
                     default: rd,
+                    span: _,
                 },
             ) => eq_ty(lt, rt) && both(ld.as_ref(), rd.as_ref(), eq_anon_const),
             _ => false,
diff --git a/src/tools/rustfmt/src/spanned.rs b/src/tools/rustfmt/src/spanned.rs
index 4d684f3c6350d..e0c7473381781 100644
--- a/src/tools/rustfmt/src/spanned.rs
+++ b/src/tools/rustfmt/src/spanned.rs
@@ -121,7 +121,7 @@ impl Spanned for ast::GenericParam {
     fn span(&self) -> Span {
         let lo = match self.kind {
             _ if !self.attrs.is_empty() => self.attrs[0].span.lo(),
-            ast::GenericParamKind::Const { kw_span, .. } => kw_span.lo(),
+            ast::GenericParamKind::Const { span, .. } => span.lo(),
             _ => self.ident.span.lo(),
         };
         let hi = if self.bounds.is_empty() {
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs
index e237662f5aa22..5a293d330fd3e 100644
--- a/src/tools/rustfmt/src/types.rs
+++ b/src/tools/rustfmt/src/types.rs
@@ -656,7 +656,7 @@ impl Rewrite for ast::GenericParam {
 
         let param_start = if let ast::GenericParamKind::Const {
             ref ty,
-            kw_span,
+            span,
             default,
         } = &self.kind
         {
@@ -678,7 +678,7 @@ impl Rewrite for ast::GenericParam {
                     default.rewrite_result(context, Shape::legacy(budget, shape.indent))?;
                 param.push_str(&rewrite);
             }
-            kw_span.lo()
+            span.lo()
         } else {
             param.push_str(rewrite_ident(context, self.ident));
             self.ident.span.lo()
diff --git a/tests/incremental/hashes/function_interfaces.rs b/tests/incremental/hashes/function_interfaces.rs
index 016a1813babd7..a1adc546390c6 100644
--- a/tests/incremental/hashes/function_interfaces.rs
+++ b/tests/incremental/hashes/function_interfaces.rs
@@ -320,7 +320,7 @@ pub fn change_return_impl_trait() -> impl Clone {
 #[cfg(not(any(cfail1,cfail4)))]
 #[rustc_clean(cfg = "cfail2", except = "opt_hir_owner_nodes")]
 #[rustc_clean(cfg = "cfail3")]
-#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes, typeck")]
+#[rustc_clean(cfg = "cfail5", except = "opt_hir_owner_nodes")]
 #[rustc_clean(cfg = "cfail6")]
 pub fn change_return_impl_trait() -> impl  Copy {
     0u32