diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
index 37fcc0d2167b2..d7b5dfec9d2fa 100644
--- a/compiler/rustc_ast/src/visit.rs
+++ b/compiler/rustc_ast/src/visit.rs
@@ -527,7 +527,7 @@ macro_rules! common_visitor_and_walkers {
             }
         }
 
-        fn visit_defaultness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, defaultness: &$($lt)? $($mut)? Defaultness) -> V::Result {
+        pub fn visit_defaultness<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, defaultness: &$($lt)? $($mut)? Defaultness) -> V::Result {
             match defaultness {
                 Defaultness::Default(span) => visit_span(vis, span),
                 Defaultness::Final => {
@@ -807,7 +807,7 @@ macro_rules! common_visitor_and_walkers {
             visit_foreign_items(vis, items)
         }
 
-        fn walk_define_opaques<$($lt,)? V: $Visitor$(<$lt>)?>(
+        pub fn walk_define_opaques<$($lt,)? V: $Visitor$(<$lt>)?>(
             visitor: &mut V,
             define_opaque: &$($lt)? $($mut)? Option<ThinVec<(NodeId, Path)>>,
         ) -> V::Result {
@@ -1225,6 +1225,27 @@ macro_rules! common_visitor_and_walkers {
             V::Result::output()
         }
 
+        pub fn walk_stmt<$($lt,)? V: $Visitor$(<$lt>)?>(
+            vis: &mut V,
+            statement: &$($lt)? $($mut)? Stmt,
+        ) -> V::Result {
+            let Stmt { id, kind, span } = statement;
+            try_visit!(visit_id(vis, id));
+            match kind {
+                StmtKind::Let(local) => try_visit!(vis.visit_local(local)),
+                StmtKind::Item(item) => try_visit!(vis.visit_item(item)),
+                StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(vis.visit_expr(expr)),
+                StmtKind::Empty => {}
+                StmtKind::MacCall(mac) => {
+                    let MacCallStmt { mac, attrs, style: _, tokens: _ } = &$($mut)? **mac;
+                    walk_list!(vis, visit_attribute, attrs);
+                    try_visit!(vis.visit_mac_call(mac));
+                }
+            }
+            try_visit!(visit_span(vis, span));
+            V::Result::output()
+        }
+
         pub fn walk_path<$($lt,)? V: $Visitor$(<$lt>)?>(
             vis: &mut V,
             path: &$($lt)? $($mut)? Path,
@@ -1944,20 +1965,3 @@ fn visit_nested_use_tree<'a, V: Visitor<'a>>(
 ) -> V::Result {
     vis.visit_nested_use_tree(nested_tree, nested_id)
 }
-
-pub fn walk_stmt<'a, V: Visitor<'a>>(visitor: &mut V, statement: &'a Stmt) -> V::Result {
-    let Stmt { id, kind, span: _ } = statement;
-    try_visit!(visit_id(visitor, id));
-    match kind {
-        StmtKind::Let(local) => try_visit!(visitor.visit_local(local)),
-        StmtKind::Item(item) => try_visit!(visitor.visit_item(item)),
-        StmtKind::Expr(expr) | StmtKind::Semi(expr) => try_visit!(visitor.visit_expr(expr)),
-        StmtKind::Empty => {}
-        StmtKind::MacCall(mac) => {
-            let MacCallStmt { mac, attrs, style: _, tokens: _ } = &**mac;
-            walk_list!(visitor, visit_attribute, attrs);
-            try_visit!(visitor.visit_mac_call(mac));
-        }
-    }
-    V::Result::output()
-}
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index af279e07acc6e..4b398cc4c44e6 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -237,7 +237,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();
 
@@ -463,7 +463,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             late: true,
                             expr: None,
                         },
-                        self.lower_span(abi_span),
+                        abi_span,
                     ));
                     clobbered.insert(clobber);
                 }
@@ -497,12 +497,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 c3222b79e55c9..5f3b717157dab 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -23,7 +23,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> hir::Block<'hir> {
         let (stmts, expr) = self.lower_stmts(&b.stmts);
         let rules = self.lower_block_check_mode(&b.rules);
-        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(
@@ -39,7 +39,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) => {
@@ -50,7 +50,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 }
                         },
                     ));
@@ -63,7 +63,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 });
                     }
                 }
@@ -72,7 +72,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 => {}
@@ -107,7 +107,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, l.span);
         self.arena.alloc(hir::LetStmt { hir_id, super_, 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 9bfcd232221ba..15930a6f6908c 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -83,7 +83,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         item_id: NodeId,
         is_in_trait_impl: bool,
     ) -> 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, is_in_trait_impl);
         match sig_id {
             Ok(sig_id) => {
@@ -92,9 +92,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let decl = self.lower_delegation_decl(sig_id, param_count, c_variadic, span);
                 let sig = self.lower_delegation_sig(sig_id, decl, span);
                 let body_id = self.lower_delegation_body(delegation, is_method, param_count, span);
-                let ident = self.lower_ident(delegation.ident);
                 let generics = self.lower_delegation_generics(span);
-                DelegationResults { body_id, sig, ident, generics }
+                DelegationResults { body_id, sig, ident: delegation.ident, generics }
             }
             Err(err) => self.generate_delegation_error(err, span),
         }
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 15e736261d583..a0902dcac2333 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -13,7 +13,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::errors::report_lit_error;
 use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
+use rustc_span::{DesugaringKind, Ident, Span, Symbol, sym};
 use thin_vec::{ThinVec, thin_vec};
 use visit::{Visitor, walk_expr};
 
@@ -69,7 +69,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() {
@@ -130,7 +130,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);
@@ -145,10 +145,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }
                 ExprKind::Lit(token_lit) => hir::ExprKind::Lit(self.lower_lit(token_lit, e.span)),
                 ExprKind::IncludedBytes(byte_sym) => {
-                    let lit = respan(
-                        self.lower_span(e.span),
-                        LitKind::ByteStr(*byte_sym, StrStyle::Cooked),
-                    );
+                    let lit = respan(e.span, LitKind::ByteStr(*byte_sym, StrStyle::Cooked));
                     hir::ExprKind::Lit(lit)
                 }
                 ExprKind::Cast(expr, ty) => {
@@ -169,7 +166,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),
@@ -194,7 +191,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             this.lower_block(body, false),
                             opt_label,
                             hir::LoopSource::Loop,
-                            this.lower_span(*span),
+                            *span,
                         )
                     })
                 }
@@ -207,7 +204,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::Use(expr, use_kw_span) => self.lower_expr_use(*use_kw_span, expr),
                 ExprKind::Closure(box Closure {
                     binder,
@@ -279,9 +278,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)
                 }
@@ -329,7 +326,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 {
@@ -376,7 +373,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ExprKind::MacCall(_) => panic!("{:?} shouldn't exist here", e.span),
             };
 
-            hir::Expr { hir_id: expr_hir_id, kind, span: self.lower_span(e.span) }
+            hir::Expr { hir_id: expr_hir_id, kind, span: e.span }
         })
     }
 
@@ -429,7 +426,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 LitKind::Err(guar)
             }
         };
-        respan(self.lower_span(span), lit_kind)
+        respan(span, lit_kind)
     }
 
     fn lower_unop(&mut self, u: UnOp) -> hir::UnOp {
@@ -441,11 +438,11 @@ 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_assign_op(&mut self, a: AssignOp) -> AssignOp {
-        Spanned { node: a.node, span: self.lower_span(a.span) }
+        Spanned { node: a.node, span: a.span }
     }
 
     fn lower_legacy_const_generics(
@@ -513,7 +510,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,
         })));
 
@@ -573,7 +570,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 span = span.with_hi(cond.span.hi());
         hir::ExprKind::Loop(block, opt_label, hir::LoopSource::While, span)
     }
 
@@ -635,7 +632,6 @@ 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);
         self.lower_attrs(hir_id, &arm.attrs, arm.span);
         let is_never_pattern = pat.is_never_pattern();
         // We need to lower the body even if it's unneeded for never pattern in match,
@@ -650,8 +646,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             if !is_never_pattern {
                 if self.tcx.features().never_patterns() {
                     // If the feature is off we already emitted the error after parsing.
-                    let suggestion = span.shrink_to_hi();
-                    self.dcx().emit_err(MatchArmWithNoBody { span, suggestion });
+                    let suggestion = arm.span.shrink_to_hi();
+                    self.dcx().emit_err(MatchArmWithNoBody { span: arm.span, suggestion });
                 }
             } else if let Some(body) = &arm.body {
                 self.dcx().emit_err(NeverPatternWithBody { span: body.span });
@@ -666,16 +662,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 expr: None,
                 hir_id: self.next_id(),
                 rules: hir::BlockCheckMode::DefaultBlock,
-                span,
+                span: arm.span,
                 targeted_by_break: false,
             });
             self.arena.alloc(hir::Expr {
                 hir_id: self.next_id(),
-                kind: hir::ExprKind::Loop(block, None, hir::LoopSource::Loop, span),
-                span,
+                kind: hir::ExprKind::Loop(block, None, hir::LoopSource::Loop, arm.span),
+                span: arm.span,
             })
         };
-        hir::Arm { hir_id, pat, guard, body, span }
+        hir::Arm { hir_id, pat, guard, body, span: arm.span }
     }
 
     /// Lower/desugar a coroutine construct.
@@ -710,7 +706,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(Arc::clone(&self.allow_gen_future)),
                 );
                 let resume_ty =
@@ -728,12 +724,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))
@@ -741,8 +732,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,
@@ -773,7 +763,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,
@@ -828,20 +818,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,
@@ -990,8 +984,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)
         };
 
@@ -1000,13 +993,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 { ... }
@@ -1087,8 +1075,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),
         });
@@ -1133,7 +1121,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)
             }
         };
@@ -1201,8 +1189,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`.
@@ -1243,11 +1231,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![];
@@ -1262,7 +1246,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;`.
@@ -1397,7 +1381,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let unit_struct_pat = hir::PatKind::Expr(self.arena.alloc(hir::PatExpr {
                         kind: hir::PatExprKind::Path(qpath),
                         hir_id: self.next_id(),
-                        span: self.lower_span(lhs.span),
+                        span: lhs.span,
                     }));
                     return self.pat_without_dbm(lhs.span, unit_struct_pat);
                 }
@@ -1408,10 +1392,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(
@@ -1455,11 +1439,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
@@ -1499,7 +1482,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])
     }
@@ -1557,14 +1540,14 @@ 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))),
+            self.arena.alloc(hir::QPath::LangItem(lang_item, span)),
             fields,
             hir::StructTailExpr::None,
         )
@@ -1580,7 +1563,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> Option<Label> {
         let label = opt_label?;
         self.ident_and_label_to_local_id.insert(dest_id, dest_hir_id.local_id);
-        Some(Label { ident: self.lower_ident(label.ident) })
+        Some(Label { ident: label.ident })
     }
 
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
@@ -1598,9 +1581,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.loop_scope.map(|id| Ok(id)).unwrap_or(Err(hir::LoopIdError::OutsideLoopScope))
             }
         };
-        let label = destination
-            .map(|(_, label)| label)
-            .map(|label| Label { ident: self.lower_ident(label.ident) });
+        let label = destination.map(|(_, label)| label).map(|label| Label { ident: label.ident });
         hir::Destination { label, target_id }
     }
 
@@ -1652,9 +1633,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.lower_attrs(hir_id, &f.attrs, f.span);
         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,
         }
     }
@@ -1729,7 +1710,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)
         }
@@ -1762,8 +1743,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);
 
@@ -1820,7 +1800,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 })
                 }
             };
@@ -1838,7 +1823,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             loop_block,
             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: loop_hir_id, kind, span: for_span });
 
@@ -2162,7 +2147,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`
@@ -2172,11 +2157,11 @@ 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(
-                Ident::new(name, self.lower_span(span)),
+                Ident::new(name, span),
                 self.next_id(),
                 Res::Err,
             )),
@@ -2204,7 +2189,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)],
             }),
@@ -2224,7 +2209,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,
@@ -2257,7 +2242,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(
@@ -2266,13 +2251,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(
@@ -2280,13 +2259,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 9d40a7386f69c..ce3bec6368661 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -110,8 +110,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))),
         })
@@ -138,15 +138,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn lower_item(&mut self, i: &Item) -> &'hir hir::Item<'hir> {
-        let vis_span = self.lower_span(i.vis.span);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
         let attrs = self.lower_attrs(hir_id, &i.attrs, i.span);
-        let kind = self.lower_item_kind(i.span, i.id, hir_id, attrs, vis_span, &i.kind);
+        let kind = self.lower_item_kind(i.span, i.id, hir_id, attrs, i.vis.span, &i.kind);
         let item = hir::Item {
             owner_id: hir_id.expect_owner(),
             kind,
-            vis_span,
-            span: self.lower_span(i.span),
+            vis_span: i.vis.span,
+            span: i.span,
             has_delayed_lints: !self.delayed_lints.is_empty(),
         };
         self.arena.alloc(item)
@@ -163,8 +162,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::ItemKind<'hir> {
         match i {
             ItemKind::ExternCrate(orig_name, ident) => {
-                let ident = self.lower_ident(*ident);
-                hir::ItemKind::ExternCrate(*orig_name, ident)
+                hir::ItemKind::ExternCrate(*orig_name, *ident)
             }
             ItemKind::Use(use_tree) => {
                 // Start with an empty prefix.
@@ -180,11 +178,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 expr: e,
                 define_opaque,
             }) => {
-                let ident = self.lower_ident(*ident);
                 let (ty, body_id) =
                     self.lower_const_item(t, span, e.as_deref(), ImplTraitPosition::StaticTy);
                 self.lower_define_opaque(hir_id, define_opaque);
-                hir::ItemKind::Static(*m, ident, ty, body_id)
+                hir::ItemKind::Static(*m, *ident, ty, body_id)
             }
             ItemKind::Const(box ast::ConstItem {
                 ident,
@@ -194,7 +191,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 define_opaque,
                 ..
             }) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, (ty, body_id)) = self.lower_generics(
                     generics,
                     id,
@@ -204,7 +200,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     },
                 );
                 self.lower_define_opaque(hir_id, &define_opaque);
-                hir::ItemKind::Const(ident, generics, ty, body_id)
+                hir::ItemKind::Const(*ident, generics, ty, body_id)
             }
             ItemKind::Fn(box Fn {
                 sig: FnSig { decl, header, span: fn_sig_span },
@@ -239,12 +235,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     let sig = hir::FnSig {
                         decl,
                         header: this.lower_fn_header(*header, hir::Safety::Safe, attrs),
-                        span: this.lower_span(*fn_sig_span),
+                        span: *fn_sig_span,
                     };
                     this.lower_define_opaque(hir_id, define_opaque);
-                    let ident = this.lower_ident(*ident);
                     hir::ItemKind::Fn {
-                        ident,
+                        ident: *ident,
                         sig,
                         generics,
                         body: body_id,
@@ -252,15 +247,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     }
                 })
             }
-            ItemKind::Mod(_, ident, mod_kind) => {
-                let ident = self.lower_ident(*ident);
-                match mod_kind {
-                    ModKind::Loaded(items, _, spans, _) => {
-                        hir::ItemKind::Mod(ident, self.lower_mod(items, spans))
-                    }
-                    ModKind::Unloaded => panic!("`mod` items should have been loaded by now"),
+            ItemKind::Mod(_, ident, mod_kind) => match mod_kind {
+                ModKind::Loaded(items, _, spans, _) => {
+                    hir::ItemKind::Mod(*ident, self.lower_mod(items, spans))
                 }
-            }
+                ModKind::Unloaded => panic!("`mod` items should have been loaded by now"),
+            },
             ItemKind::ForeignMod(fm) => hir::ItemKind::ForeignMod {
                 abi: fm.abi.map_or(ExternAbi::FALLBACK, |abi| self.lower_abi(abi)),
                 items: self
@@ -282,7 +274,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 //
                 // type Foo = Foo1
                 // opaque type Foo1: Trait
-                let ident = self.lower_ident(*ident);
                 let mut generics = generics.clone();
                 add_ty_alias_where_clause(&mut generics, *where_clauses, true);
                 let (generics, ty) = self.lower_generics(
@@ -308,10 +299,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         ),
                     },
                 );
-                hir::ItemKind::TyAlias(ident, generics, ty)
+                hir::ItemKind::TyAlias(*ident, generics, ty)
             }
             ItemKind::Enum(ident, generics, enum_definition) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, variants) = self.lower_generics(
                     generics,
                     id,
@@ -322,27 +312,25 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         )
                     },
                 );
-                hir::ItemKind::Enum(ident, generics, hir::EnumDef { variants })
+                hir::ItemKind::Enum(*ident, generics, hir::EnumDef { variants })
             }
             ItemKind::Struct(ident, generics, struct_def) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, struct_def) = self.lower_generics(
                     generics,
                     id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| this.lower_variant_data(hir_id, i, struct_def),
                 );
-                hir::ItemKind::Struct(ident, generics, struct_def)
+                hir::ItemKind::Struct(*ident, generics, struct_def)
             }
             ItemKind::Union(ident, generics, vdata) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, vdata) = self.lower_generics(
                     generics,
                     id,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Generic),
                     |this| this.lower_variant_data(hir_id, i, vdata),
                 );
-                hir::ItemKind::Union(ident, generics, vdata)
+                hir::ItemKind::Union(*ident, generics, vdata)
             }
             ItemKind::Impl(box Impl {
                 safety,
@@ -403,7 +391,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),
@@ -418,7 +406,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 }))
             }
             ItemKind::Trait(box Trait { is_auto, safety, ident, generics, bounds, items }) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, (safety, items, bounds)) = self.lower_generics(
                     generics,
                     id,
@@ -435,10 +422,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (safety, items, bounds)
                     },
                 );
-                hir::ItemKind::Trait(*is_auto, safety, ident, generics, bounds, items)
+                hir::ItemKind::Trait(*is_auto, safety, *ident, generics, bounds, items)
             }
             ItemKind::TraitAlias(ident, generics, bounds) => {
-                let ident = self.lower_ident(*ident);
                 let (generics, bounds) = self.lower_generics(
                     generics,
                     id,
@@ -450,10 +436,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         )
                     },
                 );
-                hir::ItemKind::TraitAlias(ident, generics, bounds)
+                hir::ItemKind::TraitAlias(*ident, generics, bounds)
             }
             ItemKind::MacroDef(ident, MacroDef { body, macro_rules }) => {
-                let ident = self.lower_ident(*ident);
                 let body = P(self.lower_delim_args(body));
                 let def_id = self.local_def_id(id);
                 let def_kind = self.tcx.def_kind(def_id);
@@ -464,7 +449,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     );
                 };
                 let macro_def = self.arena.alloc(ast::MacroDef { body, macro_rules: *macro_rules });
-                hir::ItemKind::Macro(ident, macro_def, macro_kind)
+                hir::ItemKind::Macro(*ident, macro_def, macro_kind)
             }
             ItemKind::Delegation(box delegation) => {
                 let delegation_results = self.lower_delegation(delegation, id, false);
@@ -524,7 +509,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 let res = self.lower_import_res(id, path.span);
                 let path = self.lower_use_path(res, &path, ParamMode::Explicit);
-                let ident = self.lower_ident(ident);
                 hir::ItemKind::Use(path, hir::UseKind::Single(ident))
             }
             UseTreeKind::Glob => {
@@ -599,7 +583,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             owner_id,
                             kind,
                             vis_span,
-                            span: this.lower_span(use_tree.span),
+                            span: use_tree.span,
                             has_delayed_lints: !this.delayed_lints.is_empty(),
                         };
                         hir::OwnerNode::Item(this.arena.alloc(item))
@@ -665,7 +649,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 (
                     ident,
                     hir::ForeignItemKind::Fn(
-                        hir::FnSig { header, decl, span: self.lower_span(sig.span) },
+                        hir::FnSig { header, decl, span: sig.span },
                         fn_args,
                         generics,
                     ),
@@ -695,10 +679,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let item = hir::ForeignItem {
             owner_id,
-            ident: self.lower_ident(*ident),
+            ident: *ident,
             kind,
-            vis_span: self.lower_span(i.vis.span),
-            span: self.lower_span(i.span),
+            vis_span: i.vis.span,
+            span: i.span,
             has_delayed_lints: !self.delayed_lints.is_empty(),
         };
         self.arena.alloc(item)
@@ -716,8 +700,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
             def_id: self.local_def_id(v.id),
             data: self.lower_variant_data(hir_id, item_kind, &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,
         }
     }
 
@@ -795,15 +779,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs, f.span);
         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,
             default: f.default.as_ref().map(|v| self.lower_anon_const_to_anon_const(v)),
             ty,
             safety: self.lower_safety(f.safety, hir::Safety::Safe),
@@ -954,10 +938,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let item = hir::TraitItem {
             owner_id: trait_item_def_id,
-            ident: self.lower_ident(ident),
+            ident,
             generics,
             kind,
-            span: self.lower_span(i.span),
+            span: i.span,
             defaultness: hir::Defaultness::Default { has_value: has_default },
             has_delayed_lints: !self.delayed_lints.is_empty(),
         };
@@ -1089,11 +1073,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let item = hir::ImplItem {
             owner_id: hir_id.expect_owner(),
-            ident: self.lower_ident(ident),
+            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,
             has_delayed_lints: !self.delayed_lints.is_empty(),
             trait_item_def_id: self
@@ -1115,9 +1099,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)
@@ -1156,8 +1138,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,
         }
     }
 
@@ -1197,9 +1179,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     None
                 };
                 let (postcond, body) = if let Some(ens) = &contract.ensures {
-                    let ens_span = this.lower_span(ens.span);
                     let ens_span =
-                        this.mark_span_with_reason(DesugaringKind::Contract, ens_span, None);
+                        this.mark_span_with_reason(DesugaringKind::Contract, ens.span, None);
                     // Set up the postcondition `let` statement.
                     let check_ident: Ident =
                         Ident::from_str_and_span("__ensures_checker", ens_span);
@@ -1289,7 +1270,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 if attrs.iter().any(|a| a.has_name(sym::rustc_intrinsic))
                     || this.tcx.is_sdylib_interface_build()
                 {
-                    let span = this.lower_span(span);
                     let empty_block = hir::Block {
                         hir_id: this.next_id(),
                         stmts: &[],
@@ -1415,8 +1395,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 {
@@ -1528,7 +1508,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)
@@ -1548,7 +1528,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(
@@ -1760,8 +1740,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);
@@ -1804,7 +1784,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 return None;
             };
-            Some((self.lower_span(path.span), did))
+            Some((path.span, did))
         });
         let define_opaque = self.arena.alloc_from_iter(define_opaque);
         self.define_opaque = Some(define_opaque);
@@ -1838,7 +1818,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 None => span_accum,
             }
         });
-        let span = self.lower_span(span);
         let hir_id = self.next_id();
         let kind = self.arena.alloc(match kind {
             GenericParamKind::Const { .. } => return None,
@@ -1846,7 +1825,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let def_id = self.local_def_id(id).to_def_id();
                 let hir_id = self.next_id();
                 let res = Res::Def(DefKind::TyParam, def_id);
-                let ident = self.lower_ident(ident);
                 let ty_path = self.arena.alloc(hir::Path {
                     span: param_span,
                     res,
@@ -1880,8 +1858,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate<'hir> {
         let hir_id = self.lower_node_id(pred.id);
-        let span = self.lower_span(pred.span);
-        self.lower_attrs(hir_id, &pred.attrs, span);
+        self.lower_attrs(hir_id, &pred.attrs, pred.span);
         let kind = self.arena.alloc(match &pred.kind {
             WherePredicateKind::BoundPredicate(WhereBoundPredicate {
                 bound_generic_params,
@@ -1921,6 +1898,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 })
             }
         });
-        hir::WherePredicate { hir_id, span, kind }
+        hir::WherePredicate { hir_id, span: pred.span, kind }
     }
 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 348fe2ee40aa2..e8b07f62087e2 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -202,22 +202,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 }
 
-struct SpanLowerer {
-    is_incremental: bool,
-    def_id: LocalDefId,
-}
-
-impl SpanLowerer {
-    fn lower(&self, span: Span) -> Span {
-        if self.is_incremental {
-            span.with_parent(Some(self.def_id))
-        } else {
-            // Do not make spans relative when not using incremental compilation.
-            span
-        }
-    }
-}
-
 #[extension(trait ResolverAstLoweringExt)]
 impl ResolverAstLowering {
     fn legacy_const_generic_args(&self, expr: &Expr) -> Option<Vec<usize>> {
@@ -784,23 +768,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         })
     }
 
-    fn span_lowerer(&self) -> SpanLowerer {
-        SpanLowerer {
-            is_incremental: self.tcx.sess.opts.incremental.is_some(),
-            def_id: self.current_hir_id_owner.def_id,
-        }
-    }
-
-    /// Intercept all spans entering HIR.
-    /// Mark a span as relative to the current owning item.
-    fn lower_span(&self, span: Span) -> Span {
-        self.span_lowerer().lower(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(
@@ -838,7 +805,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,
@@ -916,7 +883,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         if attrs.is_empty() {
             &[]
         } else {
-            let lowered_attrs = self.lower_attrs_vec(attrs, self.lower_span(target_span), id);
+            let lowered_attrs = self.lower_attrs_vec(attrs, target_span, id);
 
             assert_eq!(id.owner, self.current_hir_id_owner);
             let ret = self.arena.alloc_from_iter(lowered_attrs);
@@ -942,13 +909,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         target_span: Span,
         target_hir_id: HirId,
     ) -> Vec<hir::Attribute> {
-        let l = self.span_lowerer();
         self.attribute_parser.parse_attribute_list(
             attrs,
             target_span,
             target_hir_id,
             OmitDoc::Lower,
-            |s| l.lower(s),
             |l| {
                 self.delayed_lints.push(DelayedLint::AttributeParsing(l));
             },
@@ -1090,10 +1055,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,
         }
     }
 
@@ -1139,7 +1104,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 if ty.is_maybe_parenthesised_infer() {
                     return GenericArg::Infer(hir::InferArg {
                         hir_id: self.lower_node_id(ty.id),
-                        span: self.lower_span(ty.span),
+                        span: ty.span,
                     });
                 }
 
@@ -1221,7 +1186,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 bounds,
                 TaggedRef::new(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);
@@ -1238,7 +1203,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> {
@@ -1258,7 +1223,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyKind::PinnedRef(region, mt) => {
                 let lifetime = self.lower_ty_direct_lifetime(t, *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))]),
@@ -1309,7 +1274,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             hir_id,
                             res
                         )],
-                        span: self.lower_span(t.span),
+                        span: t.span,
                     }),
                 ))
             }
@@ -1424,7 +1389,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) }
     }
 
     fn lower_ty_direct_lifetime(
@@ -1521,7 +1486,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             def_id: opaque_ty_def_id,
             bounds,
             origin,
-            span: self.lower_span(opaque_ty_span),
+            span: opaque_ty_span,
         };
         let opaque_ty_def = self.arena.alloc(opaque_ty_def);
 
@@ -1545,7 +1510,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),
                 })
             }
@@ -1555,8 +1520,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_fn_params_to_idents(&mut self, decl: &FnDecl) -> &'hir [Option<Ident>] {
         self.arena.alloc_from_iter(decl.inputs.iter().map(|param| match param.pat.kind {
             PatKind::Missing => None,
-            PatKind::Ident(_, ident, _) => Some(self.lower_ident(ident)),
-            PatKind::Wild => Some(Ident::new(kw::Underscore, self.lower_span(param.pat.span))),
+            PatKind::Ident(_, ident, _) => Some(ident),
+            PatKind::Wild => Some(Ident::new(kw::Underscore, param.pat.span)),
             _ => {
                 self.dcx().span_delayed_bug(
                     param.pat.span,
@@ -1650,7 +1615,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),
             },
         };
 
@@ -1702,8 +1667,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),
@@ -1713,7 +1676,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 in_trait_or_impl = match fn_kind {
             FnDeclKind::Trait => Some(hir::RpitContext::Trait),
@@ -1803,10 +1766,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 LifetimeSource::OutlivesBound,
                 lifetime.ident.into(),
             )),
-            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)
+            }
         }
     }
 
@@ -1866,13 +1828,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
 
         debug!(?res);
-        self.arena.alloc(hir::Lifetime::new(
-            self.lower_node_id(new_id),
-            self.lower_ident(ident),
-            res,
-            source,
-            syntax,
-        ))
+        self.arena.alloc(hir::Lifetime::new(self.lower_node_id(new_id), ident, res, source, syntax))
     }
 
     fn lower_generic_params_mut(
@@ -1905,10 +1861,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,
         }
     }
@@ -1922,12 +1878,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             GenericParamKind::Lifetime => {
                 // AST resolution emitted an error on those parameters, so we lower them using
                 // `ParamName::Error`.
-                let ident = self.lower_ident(param.ident);
                 let param_name =
                     if let Some(LifetimeRes::Error) = self.resolver.get_lifetime_res(param.id) {
-                        ParamName::Error(ident)
+                        ParamName::Error(param.ident)
                     } else {
-                        ParamName::Plain(ident)
+                        ParamName::Plain(param.ident)
                     };
                 let kind =
                     hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit };
@@ -1958,7 +1913,7 @@ 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, span: _, default } => {
                 let ty = self
@@ -1981,7 +1936,7 @@ 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::ParamName::Plain(param.ident),
                     hir::GenericParamKind::Const { ty, default, synthetic: false },
                 )
             }
@@ -2019,12 +1974,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> {
@@ -2058,13 +2008,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 },
@@ -2090,8 +2039,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)],
             }),
         ));
 
@@ -2110,7 +2058,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // `ExprKind::Paren(ExprKind::Underscore)` and should also be lowered to `GenericArg::Infer`
         match c.value.peel_parens().kind {
             ExprKind::Underscore => {
-                let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span), ());
+                let ct_kind = hir::ConstArgKind::Infer(c.value.span, ());
                 self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
             }
             _ => self.lower_anon_const_to_const_arg(c),
@@ -2149,7 +2097,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         } else {
             // Construct an AnonConst where the expr is the "ty"'s path.
             let node_id = self.next_node_id();
-            let span = self.lower_span(span);
 
             // Add a definition for the in-band const def.
             // We're lowering a const argument that was originally thought to be a type argument,
@@ -2238,7 +2185,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 def_id,
                 hir_id,
                 body: this.lower_const_body(c.value.span, Some(&c.value)),
-                span: this.lower_span(c.value.span),
+                span: c.value.span,
             }
         }))
     }
@@ -2260,7 +2207,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> {
@@ -2280,16 +2227,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             assert!(!a.is_empty());
             self.attrs.insert(hir_id.local_id, a);
         }
-        let local = hir::LetStmt {
-            super_: None,
-            hir_id,
-            init,
-            pat,
-            els: None,
-            source,
-            span: self.lower_span(span),
-            ty: None,
-        };
+        let local =
+            hir::LetStmt { super_: None, hir_id, init, pat, els: None, source, span, ty: None };
         self.stmt(span, hir::StmtKind::Let(self.arena.alloc(local)))
     }
 
@@ -2307,7 +2246,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             pat,
             els: None,
             source: hir::LocalSource::Normal,
-            span: self.lower_span(span),
+            span,
             ty: None,
         };
         self.stmt(span, hir::StmtKind::Let(self.arena.alloc(local)))
@@ -2328,7 +2267,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)
@@ -2360,10 +2299,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]
     }
@@ -2374,7 +2313,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))
     }
 
@@ -2407,8 +2346,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,
@@ -2419,18 +2358,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> {
@@ -2443,7 +2377,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`,
@@ -2460,7 +2394,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
@@ -2470,7 +2404,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn elided_dyn_bound(&mut self, span: Span) -> &'hir hir::Lifetime {
         let r = hir::Lifetime::new(
             self.next_id(),
-            Ident::new(kw::UnderscoreLifetime, self.lower_span(span)),
+            Ident::new(kw::UnderscoreLifetime, span),
             hir::LifetimeKind::ImplicitObjectLifetimeDefault,
             LifetimeSource::Other,
             LifetimeSyntax::Implicit,
@@ -2500,7 +2434,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 e444062104813..33489fc4b0296 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -71,7 +71,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             None,
                         );
                         let kind = hir::PatExprKind::Path(qpath);
-                        let span = self.lower_span(pattern.span);
+                        let span = pattern.span;
                         let expr = hir::PatExpr { hir_id: pat_hir_id, span, kind };
                         let expr = self.arena.alloc(expr);
                         return hir::Pat {
@@ -98,10 +98,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(
@@ -306,27 +306,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         hir_id
                     }
                 };
-                hir::PatKind::Binding(
-                    annotation,
-                    binding_id,
-                    self.lower_ident(ident),
-                    lower_sub(self),
-                )
+                hir::PatKind::Binding(annotation, binding_id, ident, lower_sub(self))
             }
             Some(res) => {
                 let res = self.lower_res(res);
-                let span = self.lower_span(ident.span);
                 hir::PatKind::Expr(self.arena.alloc(hir::PatExpr {
                     kind: hir::PatExprKind::Path(hir::QPath::Resolved(
                         None,
                         self.arena.alloc(hir::Path {
-                            span,
+                            span: ident.span,
                             res,
-                            segments: arena_vec![self; hir::PathSegment::new(self.lower_ident(ident), self.next_id(), res)],
+                            segments: arena_vec![self; hir::PathSegment::new(ident, self.next_id(), res)],
                         }),
                     )),
                     hir_id: self.next_id(),
-                    span,
+                    span: ident.span,
                 }))
             }
         }
@@ -343,7 +337,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         kind: hir::PatKind<'hir>,
         hir_id: hir::HirId,
     ) -> hir::Pat<'hir> {
-        hir::Pat { hir_id, kind, span: self.lower_span(p.span), default_binding_modes: true }
+        hir::Pat { hir_id, kind, span: p.span, default_binding_modes: true }
     }
 
     /// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
@@ -389,7 +383,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         expr: &Expr,
         allow_paths: bool,
     ) -> &'hir hir::PatExpr<'hir> {
-        let span = self.lower_span(expr.span);
+        let span = expr.span;
         let err =
             |guar| hir::PatExprKind::Lit { lit: respan(span, LitKind::Err(guar)), negated: false };
         let kind = match &expr.kind {
@@ -468,13 +462,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
         };
 
-        hir::TyPat { hir_id: pat_hir_id, kind: node, span: self.lower_span(pattern.span) }
+        hir::TyPat { hir_id: pat_hir_id, kind: node, span: pattern.span }
     }
 
     /// Lowers the range end of an exclusive range (`2..5`) to an inclusive range 2..=(5 - 1).
     /// This way the type system doesn't have to handle the distinction between inclusive/exclusive ranges.
     fn lower_excluded_range_end(&mut self, e: &AnonConst) -> &'hir hir::ConstArg<'hir> {
-        let span = self.lower_span(e.value.span);
+        let span = e.value.span;
         let unstable_span = self.mark_span_with_reason(
             DesugaringKind::PatTyRange,
             span,
@@ -529,10 +523,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         let unstable_span = self.mark_span_with_reason(
             DesugaringKind::PatTyRange,
-            self.lower_span(span),
+            span,
             Some(Arc::clone(&self.allow_pattern_type)),
         );
-        let span = self.lower_span(base_type);
+        let span = base_type;
 
         let path_expr = hir::Expr {
             hir_id: self.next_id(),
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index c80ef275c801a..85e5865ae8e40 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -138,11 +138,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 {
@@ -243,7 +241,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     None,
                 )
             })),
-            span: self.lower_span(p.span),
+            span: p.span,
         })
     }
 
@@ -401,7 +399,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,
@@ -580,13 +578,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_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index ad48eb1498e11..820c0b25eaac4 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -572,16 +572,10 @@ impl<'sess> AttributeParser<'sess, Early> {
             sess,
             stage: PhantomData,
         };
-        let mut parsed = p.parse_attribute_list(
-            attrs,
-            target_span,
-            target_node_id,
-            OmitDoc::Skip,
-            std::convert::identity,
-            |_lint| {
+        let mut parsed =
+            p.parse_attribute_list(attrs, target_span, target_node_id, OmitDoc::Skip, |_lint| {
                 panic!("can't emit lints here for now (nothing uses this atm)");
-            },
-        );
+            });
         assert!(parsed.len() <= 1);
 
         parsed.pop()
@@ -616,7 +610,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         target_id: S::Id,
         omit_doc: OmitDoc,
 
-        lower_span: impl Copy + Fn(Span) -> Span,
         mut emit_lint: impl FnMut(AttributeLint<S::Id>),
     ) -> Vec<Attribute> {
         let mut attributes = Vec::new();
@@ -648,7 +641,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     attributes.push(Attribute::Parsed(AttributeKind::DocComment {
                         style: attr.style,
                         kind: *comment_kind,
-                        span: lower_span(attr.span),
+                        span: attr.span,
                         comment: *symbol,
                     }))
                 }
@@ -680,7 +673,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                     target_id,
                                     emit_lint: &mut emit_lint,
                                 },
-                                attr_span: lower_span(attr.span),
+                                attr_span: attr.span,
                                 template,
                                 attr_path: path.get_attribute_path(),
                             };
@@ -705,10 +698,10 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
                         attributes.push(Attribute::Unparsed(Box::new(AttrItem {
                             path: AttrPath::from_ast(&n.item.path),
-                            args: self.lower_attr_args(&n.item.args, lower_span),
+                            args: self.lower_attr_args(&n.item.args),
                             id: HashIgnoredAttrId { attr_id: attr.id },
                             style: attr.style,
-                            span: lower_span(attr.span),
+                            span: attr.span,
                         })));
                     }
                 }
@@ -740,7 +733,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         Late::parsers().0.contains_key(path)
     }
 
-    fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {
+    fn lower_attr_args(&self, args: &ast::AttrArgs) -> AttrArgs {
         match args {
             ast::AttrArgs::Empty => AttrArgs::Empty,
             ast::AttrArgs::Delimited(args) => AttrArgs::Delimited(args.clone()),
@@ -751,8 +744,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 // In valid code the value always ends up as a single literal. Otherwise, a dummy
                 // literal suffices because the error is handled elsewhere.
                 let lit = if let ast::ExprKind::Lit(token_lit) = expr.kind
-                    && let Ok(lit) =
-                        ast::MetaItemLit::from_token_lit(token_lit, lower_span(expr.span))
+                    && let Ok(lit) = ast::MetaItemLit::from_token_lit(token_lit, expr.span)
                 {
                     lit
                 } else {
@@ -767,7 +759,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                         span: DUMMY_SP,
                     }
                 };
-                AttrArgs::Eq { eq_span: lower_span(*eq_span), expr: lit }
+                AttrArgs::Eq { eq_span: *eq_span, expr: lit }
             }
         }
     }
diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 4b3ecad307fe7..b45ee5a5f26d0 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -498,6 +498,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 a128f8d31a134..39e0ec544ff93 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -433,19 +433,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,
@@ -478,6 +487,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 381d780077d19..362e4d4e1c646 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -259,6 +259,11 @@ impl SubstitutionPart {
             .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() }
+    }
+
     /// Try to turn a replacement into an addition when the span that is being
     /// overwritten matches either the prefix or suffix of the replacement.
     fn trim_trivial_replacements(&mut self, sm: &SourceMap) {
@@ -303,6 +308,21 @@ fn as_substr<'a>(original: &'a str, suggestion: &'a str) -> Option<(usize, &'a s
 }
 
 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(
@@ -1612,6 +1632,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)
             };
 
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 757a7e1c8e77f..a2069fb84dc91 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -1066,7 +1066,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 2de09aa1a2802..f98f22733fafb 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -136,7 +136,7 @@ macro_rules! ast_fragments {
                 T::fragment_to_output(self)
             }
 
-            pub(crate) fn mut_visit_with(&mut self, vis: &mut impl MutVisitor) {
+            pub fn mut_visit_with(&mut self, vis: &mut impl MutVisitor) {
                 match self {
                     AstFragment::OptExpr(opt_expr) => {
                         if let Some(expr) = opt_expr.take() {
@@ -663,7 +663,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 2815621ffdecf..c4fa77f3f767e 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -770,9 +770,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_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 6979d89a8e7bb..7a7b6a8b27c57 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -189,7 +189,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 e2caf632dd2d5..0f678307f1045 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -1,6 +1,7 @@
 use std::mem;
 
-use rustc_ast::visit::FnKind;
+use rustc_ast::mut_visit::FnKind;
+use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
 use rustc_attr_parsing::{AttributeParser, Early, OmitDoc};
 use rustc_expand::expand::AstFragment;
@@ -10,18 +11,20 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_middle::span_bug;
 use rustc_span::hygiene::LocalExpnId;
 use rustc_span::{Span, Symbol, sym};
+use smallvec::{SmallVec, smallvec};
 use tracing::debug;
 
 use crate::{ImplTraitContext, InvocationParent, Resolver};
 
+#[tracing::instrument(level = "trace", skip(resolver, fragment), ret)]
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,
-    fragment: &AstFragment,
+    fragment: &mut AstFragment,
     expansion: LocalExpnId,
 ) {
     let invocation_parent = resolver.invocation_parents[&expansion];
     let mut visitor = DefCollector { resolver, expansion, invocation_parent };
-    fragment.visit_with(&mut visitor);
+    fragment.mut_visit_with(&mut visitor);
 }
 
 /// Creates `DefId`s for nodes in the AST.
@@ -56,24 +59,20 @@ 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(&mut self, parent_def: LocalDefId, f: impl FnOnce(&mut Self)) {
         let orig_parent_def = mem::replace(&mut self.invocation_parent.parent_def, parent_def);
         f(self);
         self.invocation_parent.parent_def = orig_parent_def;
     }
 
-    fn with_impl_trait<F: FnOnce(&mut Self)>(
-        &mut self,
-        impl_trait_context: ImplTraitContext,
-        f: F,
-    ) {
+    fn with_impl_trait(&mut self, impl_trait_context: ImplTraitContext, f: impl FnOnce(&mut Self)) {
         let orig_itc =
             mem::replace(&mut self.invocation_parent.impl_trait_context, impl_trait_context);
         f(self);
         self.invocation_parent.impl_trait_context = orig_itc;
     }
 
-    fn collect_field(&mut self, field: &'a FieldDef, index: Option<usize>) {
+    fn collect_field(&mut self, field: &mut FieldDef, index: Option<usize>) {
         let index = |this: &Self| {
             index.unwrap_or_else(|| {
                 let node_id = NodeId::placeholder_from_expn_id(this.expansion);
@@ -88,10 +87,11 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
         } else {
             let name = field.ident.map_or_else(|| sym::integer(index(self)), |ident| ident.name);
             let def = self.create_def(field.id, Some(name), DefKind::Field, field.span);
-            self.with_parent(def, |this| visit::walk_field_def(this, field));
+            self.with_parent(def, |this| mut_visit::walk_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 old_parent = self.resolver.invocation_parents.insert(id, self.invocation_parent);
@@ -99,8 +99,14 @@ 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.invocation_parent.parent_def));
+        }
+    }
+
+    fn visit_item(&mut self, i: &mut Item) {
         // Pick the def data. This need not be unique, but the more
         // information we encapsulate into, the better
         let mut opt_macro_data = None;
@@ -133,18 +139,12 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     self.resolver.tcx.features(),
                     Vec::new(),
                 );
-                let attrs = parser.parse_attribute_list(
-                    &i.attrs,
-                    i.span,
-                    i.id,
-                    OmitDoc::Skip,
-                    std::convert::identity,
-                    |_l| {
+                let attrs =
+                    parser.parse_attribute_list(&i.attrs, i.span, i.id, OmitDoc::Skip, |_l| {
                         // FIXME(jdonszelmann): emit lints here properly
                         // NOTE that before new attribute parsing, they didn't happen either
                         // but it would be nice if we could change that.
-                    },
-                );
+                    });
 
                 let macro_data =
                     self.resolver.compile_macro(def, *ident, &attrs, i.span, i.id, edition);
@@ -155,7 +155,9 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             ItemKind::GlobalAsm(..) => DefKind::GlobalAsm,
             ItemKind::Use(use_tree) => {
                 self.create_def(i.id, None, DefKind::Use, use_tree.span);
-                return visit::walk_item(self, i);
+                // HIR lowers use trees as a flat stream of `ItemKind::Use`.
+                // This means all the def-ids must be parented to the module.
+                return mut_visit::walk_item(self, i);
             }
             ItemKind::MacCall(..) | ItemKind::DelegationMac(..) => {
                 return self.visit_macro_invoc(i.id);
@@ -185,68 +187,110 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     }
                     _ => {}
                 }
-                visit::walk_item(this, i);
+                mut_visit::walk_item(this, i)
             })
-        });
+        })
     }
 
-    fn visit_fn(&mut self, fn_kind: FnKind<'a>, span: Span, _: NodeId) {
-        match fn_kind {
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn visit_fn(&mut self, mut fn_kind: FnKind<'_>, fn_span: Span, _: NodeId) {
+        match &mut fn_kind {
             FnKind::Fn(
                 _ctxt,
                 _vis,
                 Fn {
-                    sig: FnSig { header, decl, span: _ }, ident, generics, contract, body, ..
+                    defaultness,
+                    ident,
+                    sig: FnSig { header, decl, span },
+                    generics,
+                    contract,
+                    body,
+                    define_opaque,
                 },
-            ) if let Some(coroutine_kind) = header.coroutine_kind => {
+            ) => {
+                mut_visit::visit_defaultness(self, defaultness);
                 self.visit_ident(ident);
                 self.visit_fn_header(header);
                 self.visit_generics(generics);
                 if let Some(contract) = contract {
                     self.visit_contract(contract);
                 }
+                self.visit_span(span);
+                mut_visit::walk_define_opaques(self, define_opaque);
 
                 // 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;
+                let FnDecl { inputs, output } = &mut **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, None, DefKind::OpaqueTy, return_span);
+                let return_def = if let Some(coroutine_kind) = header.coroutine_kind {
+                    // coroutine_kind has been visited by visit_header.
+                    let (return_id, return_span) = coroutine_kind.return_id();
+                    self.create_def(return_id, None, DefKind::OpaqueTy, return_span)
+                } else {
+                    self.invocation_parent.parent_def
+                };
                 self.with_parent(return_def, |this| this.visit_fn_ret_ty(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(), None, DefKind::Closure, span);
+                    let closure_def = if let Some(coroutine_kind) = header.coroutine_kind {
+                        self.create_def(
+                            coroutine_kind.closure_id(),
+                            None,
+                            DefKind::Closure,
+                            fn_span,
+                        )
+                    } else {
+                        self.invocation_parent.parent_def
+                    };
                     self.with_parent(closure_def, |this| this.visit_block(body));
                 }
             }
-            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(), None, DefKind::Closure, span);
-                self.with_parent(coroutine_def, |this| this.visit_expr(body));
+                let closure_def = if let Some(coroutine_kind) = coroutine_kind {
+                    self.visit_coroutine_kind(coroutine_kind);
+                    self.create_def(coroutine_kind.closure_id(), None, DefKind::Closure, fn_span)
+                } else {
+                    self.invocation_parent.parent_def
+                };
+                self.with_parent(closure_def, |this| this.visit_expr(body));
             }
-            _ => visit::walk_fn(self, fn_kind),
         }
     }
 
-    fn visit_nested_use_tree(&mut self, use_tree: &'a UseTree, id: NodeId) {
-        self.create_def(id, None, DefKind::Use, use_tree.span);
-        visit::walk_use_tree(self, use_tree);
+    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.
+                    self.create_def(*id, None, DefKind::Use, *span);
+                    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 visit_foreign_item(&mut self, fi: &mut ForeignItem) {
         let (ident, def_kind) = match fi.kind {
             ForeignItemKind::Static(box StaticItem {
                 ident,
@@ -269,14 +313,14 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         };
 
         let def = self.create_def(fi.id, Some(ident.name), def_kind, fi.span);
-
-        self.with_parent(def, |this| visit::walk_item(this, fi));
+        self.with_parent(def, |this| mut_visit::walk_item(this, fi))
     }
 
-    fn visit_variant(&mut self, v: &'a Variant) {
+    fn visit_variant(&mut self, v: &mut Variant) {
         if v.is_placeholder {
             return self.visit_macro_invoc(v.id);
         }
+
         let def = self.create_def(v.id, Some(v.ident.name), DefKind::Variant, v.span);
         self.with_parent(def, |this| {
             if let Some((ctor_kind, ctor_node_id)) = CtorKind::from_ast(&v.data) {
@@ -287,31 +331,41 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     v.span,
                 );
             }
-            visit::walk_variant(this, v)
-        });
+            mut_visit::walk_variant(this, v)
+        })
     }
 
-    fn visit_where_predicate(&mut self, pred: &'a WherePredicate) {
+    fn visit_where_predicate(&mut self, pred: &mut WherePredicate) {
         if pred.is_placeholder {
             self.visit_macro_invoc(pred.id)
         } else {
-            visit::walk_where_predicate(self, pred)
+            mut_visit::walk_where_predicate(self, pred)
         }
     }
 
-    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() {
+        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;
+            }
+        };
+        for (index, field) in fields.iter_mut().enumerate() {
             self.collect_field(field, Some(index));
         }
     }
 
-    fn visit_generic_param(&mut self, param: &'a GenericParam) {
+    fn visit_generic_param(&mut self, param: &mut GenericParam) {
         if param.is_placeholder {
-            self.visit_macro_invoc(param.id);
-            return;
+            return self.visit_macro_invoc(param.id);
         }
         let def_kind = match param.kind {
             GenericParamKind::Lifetime { .. } => DefKind::LifetimeParam,
@@ -327,11 +381,11 @@ 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_generic_param(this, param)
+        })
     }
 
-    fn visit_assoc_item(&mut self, i: &'a AssocItem, ctxt: visit::AssocCtxt) {
+    fn visit_assoc_item(&mut self, i: &mut AssocItem, ctxt: AssocCtxt) {
         let (ident, def_kind) = match &i.kind {
             AssocItemKind::Fn(box Fn { ident, .. })
             | AssocItemKind::Delegation(box Delegation { ident, .. }) => (*ident, DefKind::AssocFn),
@@ -343,43 +397,45 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         };
 
         let def = self.create_def(i.id, Some(ident.name), def_kind, i.span);
-        self.with_parent(def, |this| visit::walk_assoc_item(this, i, ctxt));
+        self.with_parent(def, |this| mut_visit::walk_assoc_item(this, i, ctxt));
     }
 
-    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 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) {
         let parent = self.create_def(constant.id, None, DefKind::AnonConst, constant.value.span);
-        self.with_parent(parent, |this| visit::walk_anon_const(this, constant));
+        self.with_parent(parent, |this| mut_visit::walk_anon_const(this, constant));
     }
 
-    fn visit_expr(&mut self, expr: &'a Expr) {
+    fn visit_expr(&mut self, expr: &mut Expr) {
         let parent_def = match expr.kind {
             ExprKind::MacCall(..) => return self.visit_macro_invoc(expr.id),
             ExprKind::Closure(..) | ExprKind::Gen(..) => {
                 self.create_def(expr.id, None, DefKind::Closure, expr.span)
             }
-            ExprKind::ConstBlock(ref constant) => {
-                for attr in &expr.attrs {
-                    visit::walk_attribute(self, attr);
+            ExprKind::ConstBlock(ref mut constant) => {
+                let Expr { id: _, kind: _, span, attrs, tokens: _ } = expr;
+                for attr in attrs {
+                    self.visit_attribute(attr);
                 }
                 let def =
                     self.create_def(constant.id, None, DefKind::InlineConst, 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));
+                self.visit_span(span);
                 return;
             }
             _ => self.invocation_parent.parent_def,
         };
 
-        self.with_parent(parent_def, |this| visit::walk_expr(this, expr))
+        self.with_parent(parent_def, |this| mut_visit::walk_expr(this, expr))
     }
 
-    fn visit_ty(&mut self, ty: &'a Ty) {
+    fn visit_ty(&mut self, ty: &mut Ty) {
         match ty.kind {
             TyKind::MacCall(..) => self.visit_macro_invoc(ty.id),
             TyKind::ImplTrait(opaque_id, _) => {
@@ -391,86 +447,93 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                 let kind = match self.invocation_parent.impl_trait_context {
                     ImplTraitContext::Universal => DefKind::TyParam,
                     ImplTraitContext::Existential => DefKind::OpaqueTy,
-                    ImplTraitContext::InBinding => return visit::walk_ty(self, ty),
+                    ImplTraitContext::InBinding => return mut_visit::walk_ty(self, ty),
                 };
                 let id = self.create_def(opaque_id, Some(name), kind, ty.span);
                 match self.invocation_parent.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))
                     }
                     ImplTraitContext::InBinding => unreachable!(),
                 };
             }
-            _ => 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),
+    fn flat_map_stmt(&mut self, mut stmt: Stmt) -> SmallVec<[Stmt; 1]> {
+        let Stmt { id, kind, span } = &mut stmt;
+        match kind {
+            StmtKind::MacCall(..) => {
+                self.visit_macro_invoc(*id);
+                smallvec![stmt]
+            }
             // FIXME(impl_trait_in_bindings): We don't really have a good way of
             // introducing the right `ImplTraitContext` here for all the cases we
             // care about, in case we want to introduce ITIB to other positions
             // such as turbofishes (e.g. `foo::<impl Fn()>(|| {})`).
-            StmtKind::Let(ref local) => self.with_impl_trait(ImplTraitContext::InBinding, |this| {
-                visit::walk_local(this, local)
-            }),
-            _ => visit::walk_stmt(self, stmt),
+            StmtKind::Let(local) => {
+                self.with_impl_trait(ImplTraitContext::InBinding, |this| {
+                    mut_visit::walk_local(this, local);
+                    this.visit_span(span);
+                });
+                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 visit_arm(&mut self, arm: &mut Arm) {
+        if arm.is_placeholder {
+            return self.visit_macro_invoc(arm.id);
+        }
+        mut_visit::walk_arm(self, arm)
     }
 
-    fn visit_expr_field(&mut self, f: &'a ExprField) {
+    fn visit_expr_field(&mut self, f: &mut ExprField) {
         if f.is_placeholder {
-            self.visit_macro_invoc(f.id)
-        } else {
-            visit::walk_expr_field(self, f)
+            return self.visit_macro_invoc(f.id);
         }
+        mut_visit::walk_expr_field(self, f)
     }
 
-    fn visit_pat_field(&mut self, fp: &'a PatField) {
+    fn visit_pat_field(&mut self, fp: &mut PatField) {
         if fp.is_placeholder {
-            self.visit_macro_invoc(fp.id)
-        } else {
-            visit::walk_pat_field(self, fp)
+            return self.visit_macro_invoc(fp.id);
         }
+        mut_visit::walk_pat_field(self, fp)
     }
 
-    fn visit_param(&mut self, p: &'a Param) {
+    fn visit_param(&mut self, p: &mut Param) {
         if p.is_placeholder {
-            self.visit_macro_invoc(p.id)
-        } else {
-            self.with_impl_trait(ImplTraitContext::Universal, |this| visit::walk_param(this, p))
+            return self.visit_macro_invoc(p.id);
         }
+        self.with_impl_trait(ImplTraitContext::Universal, |this| mut_visit::walk_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 visit_field_def(&mut self, field: &mut FieldDef) {
+        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.invocation_parent.in_attr, true);
-        visit::walk_attribute(self, attr);
+        mut_visit::walk_attribute(self, attr);
         self.invocation_parent.in_attr = orig_in_attr;
     }
 
-    fn visit_inline_asm(&mut self, asm: &'a InlineAsm) {
+    fn visit_inline_asm(&mut self, asm: &mut InlineAsm) {
         let InlineAsm {
             asm_macro: _,
             template: _,
@@ -501,7 +564,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                         DefKind::InlineConst,
                         anon_const.value.span,
                     );
-                    self.with_parent(def, |this| visit::walk_anon_const(this, anon_const));
+                    self.with_parent(def, |this| mut_visit::walk_anon_const(this, anon_const));
                 }
                 InlineAsmOperand::Sym { sym } => self.visit_inline_asm_sym(sym),
                 InlineAsmOperand::Label { block } => self.visit_block(block),
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 5864b035f73df..2115c574cf7c6 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -184,7 +184,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/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