Improved support of collapse_debuginfo attribute for macroses. Enabled by default for builtin and core/std macroses.

Author: azhogin

compiler/rustc_codegen_cranelift/src/debuginfo/line_info.rs

@@ -68,15 +68,7 @@ impl DebugContext {
         // In order to have a good line stepping behavior in debugger, we overwrite debug
         // locations of macro expansions with that of the outermost expansion site (when the macro is
         // annotated with `#[collapse_debuginfo]` or when `-Zdebug-macros` is provided).
-        let span = if tcx.should_collapse_debuginfo(span) {
-            span
-        } else {
-            // Walk up the macro expansion chain until we reach a non-expanded span.
-            // We also stop at the function body level because no line stepping can occur
-            // at the level above that.
-            rustc_span::hygiene::walk_chain(span, function_span.ctxt())
-        };
-
+        let span = tcx.collapsed_debuginfo(span, function_span.ctxt());
         match tcx.sess.source_map().lookup_line(span.lo()) {
             Ok(SourceFileAndLine { sf: file, line }) => {
                 let line_pos = file.lines()[line];

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -228,21 +228,16 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     /// In order to have a good line stepping behavior in debugger, we overwrite debug
     /// locations of macro expansions with that of the outermost expansion site (when the macro is
     /// annotated with `#[collapse_debuginfo]` or when `-Zdebug-macros` is provided).
-    fn adjust_span_for_debugging(&self, mut span: Span) -> Span {
+    fn adjust_span_for_debugging(&self, span: Span) -> Span {
         // Bail out if debug info emission is not enabled.
         if self.debug_context.is_none() {
             return span;
         }
-
-        if self.cx.tcx().should_collapse_debuginfo(span) {
-            // Walk up the macro expansion chain until we reach a non-expanded span.
-            // We also stop at the function body level because no line stepping can occur
-            // at the level above that.
-            // Use span of the outermost expansion site, while keeping the original lexical scope.
-            span = rustc_span::hygiene::walk_chain(span, self.mir.span.ctxt());
-        }
-
-        span
+        // Walk up the macro expansion chain until we reach a non-expanded span.
+        // We also stop at the function body level because no line stepping can occur
+        // at the level above that.
+        // Use span of the outermost expansion site, while keeping the original lexical scope.
+        self.cx.tcx().collapsed_debuginfo(span, self.mir.span.ctxt())
     }
 
     fn spill_operand_to_stack(

compiler/rustc_expand/src/base.rs

@@ -783,7 +783,8 @@ impl SyntaxExtension {
         let local_inner_macros = attr::find_by_name(attrs, sym::macro_export)
             .and_then(|macro_export| macro_export.meta_item_list())
             .is_some_and(|l| attr::list_contains_name(&l, sym::local_inner_macros));
-        let collapse_debuginfo = attr::contains_name(attrs, sym::collapse_debuginfo);
+        let collapse_debuginfo = attr::contains_name(attrs, sym::collapse_debuginfo)
+            || attr::contains_name(attrs, sym::rustc_builtin_macro);
         tracing::debug!(?local_inner_macros, ?collapse_debuginfo, ?allow_internal_unsafe);
 
         let (builtin_name, helper_attrs) = attr::find_by_name(attrs, sym::rustc_builtin_macro)

compiler/rustc_middle/src/ty/mod.rs

@@ -50,7 +50,7 @@ use rustc_session::lint::LintBuffer;
 pub use rustc_session::lint::RegisteredTools;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
-use rustc_span::{ExpnId, ExpnKind, Span};
+use rustc_span::{ExpnId, ExpnKind, Span, SyntaxContext};
 use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
 pub use rustc_target::abi::{ReprFlags, ReprOptions};
 pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
@@ -2515,21 +2515,22 @@ impl<'tcx> TyCtxt<'tcx> {
         (ident, scope)
     }
 
-    /// Returns `true` if the debuginfo for `span` should be collapsed to the outermost expansion
-    /// site. Only applies when `Span` is the result of macro expansion.
-    ///
-    /// - If the `collapse_debuginfo` feature is enabled then debuginfo is not collapsed by default
-    ///   and only when a macro definition is annotated with `#[collapse_debuginfo]`.
-    /// - If `collapse_debuginfo` is not enabled, then debuginfo is collapsed by default.
-    ///
-    /// When `-Zdebug-macros` is provided then debuginfo will never be collapsed.
-    pub fn should_collapse_debuginfo(self, span: Span) -> bool {
-        !self.sess.opts.unstable_opts.debug_macros
-            && if self.features().collapse_debuginfo {
-                span.in_macro_expansion_with_collapse_debuginfo()
-            } else {
-                span.from_expansion()
-            }
+    /// Macros in standart library (core/alloc/std)
+    pub fn in_std_macro(self, macro_def_id: DefId) -> bool {
+        let crate_name = self.crate_name(macro_def_id.krate);
+        [sym::core, sym::alloc, sym::std].contains(&crate_name)
+    }
+
+    pub fn collapsed_debuginfo(self, span: Span, upto: SyntaxContext) -> Span {
+        let collapse_enabled = !self.sess.opts.unstable_opts.debug_macros;
+        let attr_enabled = self.features().collapse_debuginfo;
+        rustc_span::hygiene::walk_chain_collapsed(
+            span,
+            upto,
+            collapse_enabled,
+            attr_enabled,
+            |macro_def_id| self.in_std_macro(macro_def_id),
+        )
     }
 
     #[inline]

compiler/rustc_span/src/hygiene.rs

@@ -377,7 +377,7 @@ impl HygieneData {
         self.local_expn_data[expn_id].as_ref().expect("no expansion data for an expansion ID")
     }
 
-    fn expn_data(&self, expn_id: ExpnId) -> &ExpnData {
+    pub fn expn_data(&self, expn_id: ExpnId) -> &ExpnData {
         if let Some(expn_id) = expn_id.as_local() {
             self.local_expn_data[expn_id].as_ref().expect("no expansion data for an expansion ID")
         } else {
@@ -412,7 +412,7 @@ impl HygieneData {
         self.syntax_context_data[ctxt.0 as usize].opaque_and_semitransparent
     }
 
-    fn outer_expn(&self, ctxt: SyntaxContext) -> ExpnId {
+    pub fn outer_expn(&self, ctxt: SyntaxContext) -> ExpnId {
         self.syntax_context_data[ctxt.0 as usize].outer_expn
     }
 
@@ -443,15 +443,65 @@ impl HygieneData {
     }
 
     fn walk_chain(&self, mut span: Span, to: SyntaxContext) -> Span {
+        let orig_span = span;
         debug!("walk_chain({:?}, {:?})", span, to);
         debug!("walk_chain: span ctxt = {:?}", span.ctxt());
-        while span.from_expansion() && span.ctxt() != to {
+        while span.ctxt() != to && span.from_expansion() {
             let outer_expn = self.outer_expn(span.ctxt());
             debug!("walk_chain({:?}): outer_expn={:?}", span, outer_expn);
             let expn_data = self.expn_data(outer_expn);
             debug!("walk_chain({:?}): expn_data={:?}", span, expn_data);
             span = expn_data.call_site;
         }
+        debug!("walk_chain: for span {:?} >>> return span = {:?}", orig_span, span);
+        span
+    }
+
+    /// Returns `true` if the debuginfo for `span` should be collapsed to the outermost expansion
+    /// site. Only applies when `Span` is the result of macro expansion.
+    ///
+    /// - If the `collapse_debuginfo` feature is enabled then debuginfo is not collapsed by default
+    ///   and only when a macro definition is annotated with `#[collapse_debuginfo]`.
+    /// - If `collapse_debuginfo` is not enabled, then debuginfo is collapsed by default.
+    ///
+    /// When `-Zdebug-macros` is provided then debuginfo will never be collapsed.
+    fn should_collapse_debuginfo<F: Fn(DefId) -> bool>(
+        &self,
+        span: Span,
+        collapse_enabled: bool,
+        attr_enabled: bool,
+        in_std_macro: &F,
+    ) -> bool {
+        collapse_enabled
+            && if attr_enabled {
+                span.in_macro_expansion_with_collapse_debuginfo(&self, in_std_macro)
+            } else {
+                span.from_expansion()
+            }
+    }
+
+    fn walk_chain_collapsed<F: Fn(DefId) -> bool>(
+        &self,
+        mut span: Span,
+        to: SyntaxContext,
+        collapse_enabled: bool,
+        attr_enabled: bool,
+        in_std_macro: F,
+    ) -> Span {
+        let orig_span = span;
+
+        debug!("walk_chain_collapsed({:?}, {:?})", span, to);
+        debug!("walk_chain_collapsed: span ctxt = {:?}", span.ctxt());
+        while span.ctxt() != to
+            && self.should_collapse_debuginfo(span, collapse_enabled, attr_enabled, &in_std_macro)
+        {
+            let outer_expn = self.outer_expn(span.ctxt());
+            debug!("walk_chain_collapsed({:?}): outer_expn={:?}", span, outer_expn);
+            let expn_data = self.expn_data(outer_expn);
+            debug!("walk_chain_collapsed({:?}): expn_data={:?}", span, expn_data);
+            span = expn_data.call_site;
+        }
+        debug!("walk_chain_collapsed: for span {:?} >>> return span = {:?}", orig_span, span);
         span
     }
 
@@ -571,6 +621,22 @@ pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
     HygieneData::with(|data| data.walk_chain(span, to))
 }
 
+pub fn walk_chain_collapsed<F: Fn(DefId) -> bool>(
+    span: Span,
+    to: SyntaxContext,
+    collapse_enabled: bool,
+    attr_enabled: bool,
+    in_std_macro: F,
+) -> Span {
+    HygieneData::with(|hdata| {
+        if hdata.should_collapse_debuginfo(span, collapse_enabled, attr_enabled, &in_std_macro) {
+            hdata.walk_chain_collapsed(span, to, collapse_enabled, attr_enabled, in_std_macro)
+        } else {
+            span
+        }
+    })
+}
+
 pub fn update_dollar_crate_names(mut get_name: impl FnMut(SyntaxContext) -> Symbol) {
     // The new contexts that need updating are at the end of the list and have `$crate` as a name.
     let (len, to_update) = HygieneData::with(|data| {

compiler/rustc_span/src/lib.rs

@@ -53,9 +53,9 @@ use source_map::SourceMap;
 pub mod edition;
 use edition::Edition;
 pub mod hygiene;
-use hygiene::Transparency;
 pub use hygiene::{DesugaringKind, ExpnKind, MacroKind};
 pub use hygiene::{ExpnData, ExpnHash, ExpnId, LocalExpnId, SyntaxContext};
+use hygiene::{HygieneData, Transparency};
 use rustc_data_structures::stable_hasher::HashingControls;
 pub mod def_id;
 use def_id::{CrateNum, DefId, DefPathHash, LocalDefId, LOCAL_CRATE};
@@ -570,9 +570,18 @@ impl Span {
 
     /// Returns `true` if `span` originates in a macro's expansion where debuginfo should be
     /// collapsed.
-    pub fn in_macro_expansion_with_collapse_debuginfo(self) -> bool {
-        let outer_expn = self.ctxt().outer_expn_data();
-        matches!(outer_expn.kind, ExpnKind::Macro(..)) && outer_expn.collapse_debuginfo
+    pub(crate) fn in_macro_expansion_with_collapse_debuginfo<F: Fn(DefId) -> bool>(
+        self,
+        hdata: &HygieneData,
+        in_std_macro: F,
+    ) -> bool {
+        if self.from_expansion() {
+            let outer = hdata.expn_data(hdata.outer_expn(self.ctxt())).clone();
+            let std_macro = outer.macro_def_id.is_some_and(in_std_macro);
+            !matches!(outer.kind, ExpnKind::Macro(..)) || outer.collapse_debuginfo || std_macro
+        } else {
+            false
+        }
     }
 
     /// Returns `true` if `span` originates in a derive-macro's expansion.

tests/debuginfo/collapse-debuginfo-in-non-collapse-macro.rs

@@ -0,0 +1,59 @@
+// ignore-lldb
+#![feature(collapse_debuginfo)]
+
+// Test that statement, skipped by macros, is correctly processed in debuginfo
+
+// compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:run
+// gdb-command:next
+// gdb-check:[...]#loc2[...]
+// gdb-command:step
+// gdb-command:frame
+// gdb-check:[...]#loc_call1_pre[...]
+// gdb-command:next
+// gdb-command:frame
+// gdb-check:[...]#loc_in_proxy[...]
+// gdb-command:finish
+// gdb-check:[...]#loc4[...]
+// gdb-command:next
+// gdb-command:frame
+// gdb-check:[...]#loc5[...]
+// gdb-command:continue
+
+
+macro_rules! proxy_println {
+    ($($arg:tt)*) => {{
+        println!($($arg)*); // #loc_in_proxy
+    }};
+}
+
+// Macro accepts 3 statements and removes the 2nd statement
+macro_rules! remove_second_statement {
+    ($s1:stmt; $s2:stmt; $s3:stmt;) => { $s1 $s3 }
+}
+
+fn call1() {
+    let rv = 0; // #loc_call1_pre
+    proxy_println!("one"); // #loc_call1
+}
+
+fn call2() {
+    proxy_println!("two"); // #loc_call2
+}
+
+fn call3() {
+    proxy_println!("three"); // #loc_call3
+}
+
+fn main() {
+    let ret = 0; // #break, step should go to call1
+    remove_second_statement! { // #loc1
+        call1(); // #loc2, breakpoint should set to call1, step should go call3
+        call2(); // #loc3, breakpoint should set to call3
+        call3(); // #loc4, breakpoint should set to call3, step should go closing brace
+    }
+    std::process::exit(ret); // #loc5
+}

tests/debuginfo/collapse-debuginfo-through-desugar.rs

@@ -0,0 +1,54 @@
+// ignore-lldb
+#![feature(collapse_debuginfo)]
+
+// Test that statement, skipped by macros, is correctly processed in debuginfo
+
+// compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:run
+// gdb-command:next
+// gdb-command:frame
+// gdb-check:[...]#loc2[...]
+// gdb-command:step
+// gdb-command:frame
+// gdb-command:step
+// gdb-command:frame
+// gdb-check:[...]#loc_call1_println[...]
+// gdb-command:finish
+// gdb-command:finish
+// gdb-check:[...]#loc4[...]
+// gdb-command:next
+// gdb-command:frame
+// gdb-check:[...]#loc5[...]
+// gdb-command:continue
+
+// Macro accepts 3 statements and removes the 2nd statement
+macro_rules! remove_second_statement {
+    ($s1:stmt; $s2:stmt; $s3:stmt;) => { $s1 $s3 }
+}
+
+fn call1() {
+    (||{
+        println!("one") // #loc_call1_println
+    })(); // #loc_call1
+}
+
+fn call2() {
+    println!("two"); // #loc_call2
+}
+
+fn call3() {
+    println!("three"); // #loc_call3
+}
+
+fn main() {
+    let ret = 0; // #break, step should go to call1
+    remove_second_statement! { // #loc1
+        call1(); // #loc2, breakpoint should set to call1, step should go call3
+        call2(); // #loc3, breakpoint should set to call3
+        call3(); // #loc4, breakpoint should set to call3, step should go closing brace
+    }
+    std::process::exit(ret); // #loc5
+}