Auto merge of #127241 - cjgillot:def-collector-span, r=<try>

Mark span parent in def_collector.

The current device of marking spans with a parent def-id during lowering has been frustrating me for quite some time, as it's very easy to forget marking some spans.

This PR moves such marking to the def_collector, which is responsible for creating def-ids on partially expanded AST. This is much more robust as long as visitors are exhaustive.

r? ghost

Author: bors

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()
-}

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,

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 })

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),
         }