Revert "don't drop arguments' temporaries in dbg!"

cuviper · cuviper · commit cb5a91376ec4 · 2026-04-08T09:45:57.000-07:00
This reverts commit 4f50466.
diff --git a/library/std/src/macros.rs b/library/std/src/macros.rs
@@ -5,9 +5,6 @@
 //! library.
 // ignore-tidy-dbg
 
-#[cfg(test)]
-mod tests;
-
 #[doc = include_str!("../../core/src/macros/panic.md")]
 #[macro_export]
 #[rustc_builtin_macro(std_panic)]
@@ -362,16 +359,19 @@ macro_rules! dbg {
     };
 }
 
-/// Internal macro that processes a list of expressions, binds their results
-/// with `match`, calls `eprint!` with the collected information, and returns
-/// all the evaluated expressions in a tuple.
+/// Internal macro that processes a list of expressions and produces a chain of
+/// nested `match`es, one for each expression, before finally calling `eprint!`
+/// with the collected information and returning all the evaluated expressions
+/// in a tuple.
 ///
 /// E.g. `dbg_internal!(() () (1, 2))` expands into
 /// ```rust, ignore
-/// match (1, 2) {
-///     (tmp_1, tmp_2) => {
-///         eprint!("...", &tmp_1, &tmp_2, /* some other arguments */);
-///         (tmp_1, tmp_2)
+/// match 1 {
+///     tmp_1 => match 2 {
+///         tmp_2 => {
+///             eprint!("...", &tmp_1, &tmp_2, /* some other arguments */);
+///             (tmp_1, tmp_2)
+///         }
 ///     }
 /// }
 /// ```
@@ -380,41 +380,37 @@ macro_rules! dbg {
 #[doc(hidden)]
 #[rustc_macro_transparency = "semiopaque"]
 pub macro dbg_internal {
-    (($($piece:literal),+) ($($processed:expr => $bound:ident),+) ()) => {
+    (($($piece:literal),+) ($($processed:expr => $bound:expr),+) ()) => {{
+        $crate::eprint!(
+            $crate::concat!($($piece),+),
+            $(
+                $crate::stringify!($processed),
+                // The `&T: Debug` check happens here (not in the format literal desugaring)
+                // to avoid format literal related messages and suggestions.
+                &&$bound as &dyn $crate::fmt::Debug
+            ),+,
+            // The location returned here is that of the macro invocation, so
+            // it will be the same for all expressions. Thus, label these
+            // arguments so that they can be reused in every piece of the
+            // formatting template.
+            file=$crate::file!(),
+            line=$crate::line!(),
+            column=$crate::column!()
+        );
+        // Comma separate the variables only when necessary so that this will
+        // not yield a tuple for a single expression, but rather just parenthesize
+        // the expression.
+        ($($bound),+)
+    }},
+    (($($piece:literal),*) ($($processed:expr => $bound:expr),*) ($val:expr $(,$rest:expr)*)) => {
         // Use of `match` here is intentional because it affects the lifetimes
         // of temporaries - https://stackoverflow.com/a/48732525/1063961
-        // Always put the arguments in a tuple to avoid an unused parens lint on the pattern.
-        match ($($processed,)+) {
-            ($($bound,)+) => {
-                $crate::eprint!(
-                    $crate::concat!($($piece),+),
-                    $(
-                        $crate::stringify!($processed),
-                        // The `&T: Debug` check happens here (not in the format literal desugaring)
-                        // to avoid format literal related messages and suggestions.
-                        &&$bound as &dyn $crate::fmt::Debug
-                    ),+,
-                    // The location returned here is that of the macro invocation, so
-                    // it will be the same for all expressions. Thus, label these
-                    // arguments so that they can be reused in every piece of the
-                    // formatting template.
-                    file=$crate::file!(),
-                    line=$crate::line!(),
-                    column=$crate::column!()
-                );
-                // Comma separate the variables only when necessary so that this will
-                // not yield a tuple for a single expression, but rather just parenthesize
-                // the expression.
-                ($($bound),+)
-
-            }
+        match $val {
+            tmp => $crate::macros::dbg_internal!(
+                ($($piece,)* "[{file}:{line}:{column}] {} = {:#?}\n")
+                ($($processed => $bound,)* $val => tmp)
+                ($($rest),*)
+            ),
         }
     },
-    (($($piece:literal),*) ($($processed:expr => $bound:ident),*) ($val:expr $(,$rest:expr)*)) => {
-        $crate::macros::dbg_internal!(
-            ($($piece,)* "[{file}:{line}:{column}] {} = {:#?}\n")
-            ($($processed => $bound,)* $val => tmp)
-            ($($rest),*)
-        )
-    },
 }
diff --git a/library/std/src/macros/tests.rs b/library/std/src/macros/tests.rs
diff --git a/src/tools/clippy/clippy_lints/src/dbg_macro.rs b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
@@ -5,7 +5,7 @@ use clippy_utils::macros::{MacroCall, macro_backtrace};
 use clippy_utils::source::snippet_with_applicability;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
+use rustc_hir::{Arm, Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, SyntaxContext};
@@ -92,15 +92,16 @@ impl LateLintPass<'_> for DbgMacro {
                                 (macro_call.span, String::from("()"))
                             }
                         },
-                        ExprKind::Match(args, _, _) => {
-                            let suggestion = match args.kind {
+                        ExprKind::Match(first, arms, _) => {
+                            let vals = collect_vals(first, arms);
+                            let suggestion = match *vals.as_slice() {
                                 // dbg!(1) => 1
-                                ExprKind::Tup([val]) => {
+                                [val] => {
                                     snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
                                         .to_string()
                                 },
                                 // dbg!(2, 3) => (2, 3)
-                                ExprKind::Tup([first, .., last]) => {
+                                [first, .., last] => {
                                     let snippet = snippet_with_applicability(
                                         cx,
                                         first.span.source_callsite().to(last.span.source_callsite()),
@@ -164,3 +165,39 @@ fn is_async_move_desugar<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx
 fn first_dbg_macro_in_expansion(cx: &LateContext<'_>, span: Span) -> Option<MacroCall> {
     macro_backtrace(span).find(|mc| cx.tcx.is_diagnostic_item(sym::dbg_macro, mc.def_id))
 }
+
+/// Extracts all value expressions from the `match`-tree generated by `dbg!`.
+///
+/// E.g. from
+/// ```rust, ignore
+/// match 1 {
+///     tmp_1 => match 2 {
+///         tmp_2 => {
+///             /* printing */
+///             (tmp_1, tmp_2)
+///         }
+///     }
+/// }
+/// ```
+/// this extracts `1` and `2`.
+fn collect_vals<'hir>(first: &'hir Expr<'hir>, mut arms: &'hir [Arm<'hir>]) -> Vec<&'hir Expr<'hir>> {
+    let mut vals = vec![first];
+    loop {
+        let [arm] = arms else {
+            unreachable!("dbg! macro expansion only has single-arm matches")
+        };
+
+        match is_async_move_desugar(arm.body)
+            .unwrap_or(arm.body)
+            .peel_drop_temps()
+            .kind
+        {
+            ExprKind::Block(..) => return vals,
+            ExprKind::Match(val, a, _) => {
+                vals.push(val);
+                arms = a;
+            },
+            _ => unreachable!("dbg! macro expansion only results in block or match expressions"),
+        }
+    }
+}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_primitive.stderr
@@ -2,7 +2,7 @@ error: Undefined Behavior: memory access failed: ALLOC has been freed, so this p
   --> tests/fail/dangling_pointers/dangling_primitive.rs:LL:CC
    |
 LL |         dbg!(*ptr);
-   |              ^^^^ Undefined Behavior occurred here
+   |         ^^^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
@@ -7,7 +7,7 @@ error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is unin
   --> tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC
    |
 LL |     dbg!(x.0);
-   |          ^^^ Undefined Behavior occurred here
+   |     ^^^^^^^^^ Undefined Behavior occurred here
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/tests/ui/borrowck/dbg-issue-120327.stderr b/tests/ui/borrowck/dbg-issue-120327.stderr
@@ -4,44 +4,44 @@ error[E0382]: use of moved value: `a`
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(a);
-   |          - value moved here
+   |     ------- value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider cloning the value if the performance cost is acceptable
+help: consider borrowing instead of transferring ownership
    |
-LL |     dbg!(a.clone());
-   |           ++++++++
+LL |     dbg!(&a);
+   |          +
 
 error[E0382]: use of moved value: `a`
   --> $DIR/dbg-issue-120327.rs:10:12
    |
 LL |     let a = String::new();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(1, 2, a, 1, 2);
-   |                - value moved here
+   |     ------------------- value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider cloning the value if the performance cost is acceptable
+help: consider borrowing instead of transferring ownership
    |
-LL |     dbg!(1, 2, a.clone(), 1, 2);
-   |                 ++++++++
+LL |     dbg!(1, 2, &a, 1, 2);
+   |                +
 
 error[E0382]: use of moved value: `b`
   --> $DIR/dbg-issue-120327.rs:16:12
    |
 LL |     let b: String = "".to_string();
    |         - move occurs because `b` has type `String`, which does not implement the `Copy` trait
 LL |     dbg!(a, b);
-   |             - value moved here
+   |     ---------- value moved here
 LL |     return b;
    |            ^ value used here after move
    |
-help: consider cloning the value if the performance cost is acceptable
+help: consider borrowing instead of transferring ownership
    |
-LL |     dbg!(a, b.clone());
-   |              ++++++++
+LL |     dbg!(a, &b);
+   |             +
 
 error[E0382]: use of moved value: `a`
   --> $DIR/dbg-issue-120327.rs:22:12
@@ -50,14 +50,14 @@ LL | fn x(a: String) -> String {
    |      - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     let b: String = "".to_string();
 LL |     dbg!(a, b);
-   |          - value moved here
+   |     ---------- value moved here
 LL |     return a;
    |            ^ value used here after move
    |
-help: consider cloning the value if the performance cost is acceptable
+help: consider borrowing instead of transferring ownership
    |
-LL |     dbg!(a.clone(), b);
-   |           ++++++++
+LL |     dbg!(&a, b);
+   |          +
 
 error[E0382]: use of moved value: `b`
   --> $DIR/dbg-issue-120327.rs:46:12
@@ -103,14 +103,14 @@ error[E0382]: borrow of moved value: `a`
 LL |     let a: String = "".to_string();
    |         - move occurs because `a` has type `String`, which does not implement the `Copy` trait
 LL |     let _res = get_expr(dbg!(a));
-   |                              - value moved here
+   |                         ------- value moved here
 LL |     let _l = a.len();
    |              ^ value borrowed here after move
    |
-help: consider cloning the value if the performance cost is acceptable
+help: consider borrowing instead of transferring ownership
    |
-LL |     let _res = get_expr(dbg!(a.clone()));
-   |                               ++++++++
+LL |     let _res = get_expr(dbg!(&a));
+   |                              +
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/liveness/liveness-upvars.rs b/tests/ui/liveness/liveness-upvars.rs
@@ -98,7 +98,7 @@ pub fn g<T: Default>(mut v: T) {
 }
 
 pub fn h<T: Copy + Default + std::fmt::Debug>() {
-    let mut z = T::default(); //~ WARN unused variable: `z`
+    let mut z = T::default();
     let _ = move |b| {
         loop {
             if b {
diff --git a/tests/ui/liveness/liveness-upvars.stderr b/tests/ui/liveness/liveness-upvars.stderr
@@ -156,14 +156,6 @@ LL |                 z = T::default();
    |
    = help: maybe it is overwritten before being read?
 
-warning: unused variable: `z`
-  --> $DIR/liveness-upvars.rs:101:9
-   |
-LL |     let mut z = T::default();
-   |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_z`
-   |
-   = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
-
 warning: value captured by `state` is never read
   --> $DIR/liveness-upvars.rs:131:9
    |
@@ -204,5 +196,5 @@ LL |         s = yield ();
    |
    = help: maybe it is overwritten before being read?
 
-warning: 25 warnings emitted
+warning: 24 warnings emitted
 
diff --git a/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr b/tests/ui/rfcs/rfc-2361-dbg-macro/dbg-macro-move-semantics.stderr
@@ -1,21 +1,17 @@
 error[E0382]: use of moved value: `a`
-  --> $DIR/dbg-macro-move-semantics.rs:9:18
+  --> $DIR/dbg-macro-move-semantics.rs:9:13
    |
 LL |     let a = NoCopy(0);
    |         - move occurs because `a` has type `NoCopy`, which does not implement the `Copy` trait
 LL |     let _ = dbg!(a);
-   |                  - value moved here
+   |             ------- value moved here
 LL |     let _ = dbg!(a);
-   |                  ^ value used here after move
+   |             ^^^^^^^ value used here after move
    |
-note: if `NoCopy` implemented `Clone`, you could clone the value
-  --> $DIR/dbg-macro-move-semantics.rs:4:1
+help: consider borrowing instead of transferring ownership
    |
-LL | struct NoCopy(usize);
-   | ^^^^^^^^^^^^^ consider implementing `Clone` for this type
-...
-LL |     let _ = dbg!(a);
-   |                  - you could clone this value
+LL |     let _ = dbg!(&a);
+   |                  +
 
 error: aborting due to 1 previous error
 

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ error: Undefined Behavior: memory access failed: ALLOC has been freed, so this p`
`2`	`2`	`--> tests/fail/dangling_pointers/dangling_primitive.rs:LL:CC`
`3`	`3`	`\|`
`4`	`4`	`LL \| dbg!(*ptr);`
`5`		`- \| ^^^^ Undefined Behavior occurred here`
	`5`	`+ \| ^^^^^^^^^^ Undefined Behavior occurred here`
`6`	`6`	`\|`
`7`	`7`	`= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior`
`8`	`8`	`= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ error: Undefined Behavior: reading memory at ALLOC[0x0..0x4], but memory is unin`
`7`	`7`	`--> tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC`
`8`	`8`	`\|`
`9`	`9`	`LL \| dbg!(x.0);`
`10`		`- \| ^^^ Undefined Behavior occurred here`
	`10`	`+ \| ^^^^^^^^^ Undefined Behavior occurred here`
`11`	`11`	`\|`
`12`	`12`	`= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior`
`13`	`13`	`= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ pub fn g<T: Default>(mut v: T) {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`pub fn h<T: Copy + Default + std::fmt::Debug>() {`
`101`		- let mut z = T::default(); //~ WARN unused variable: `z`
	`101`	`+ let mut z = T::default();`
`102`	`102`	`let _ = move \|b\| {`
`103`	`103`	`loop {`
`104`	`104`	`if b {`
Original file line number	Diff line number	Diff line change
`@@ -156,14 +156,6 @@ LL \| z = T::default();`
`156`	`156`	`\|`
`157`	`157`	`= help: maybe it is overwritten before being read?`
`158`	`158`
`159`		-warning: unused variable: `z`
`160`		`- --> $DIR/liveness-upvars.rs:101:9`
`161`		`- \|`
`162`		`-LL \| let mut z = T::default();`
`163`		- \| ^^^^^ help: if this is intentional, prefix it with an underscore: `_z`
`164`		`- \|`
`165`		- = note: `#[warn(unused_variables)]` implied by `#[warn(unused)]`
`166`		`-`
`167`	`159`	warning: value captured by `state` is never read
`168`	`160`	`--> $DIR/liveness-upvars.rs:131:9`
`169`	`161`	`\|`
`@@ -204,5 +196,5 @@ LL \| s = yield ();`
`204`	`196`	`\|`
`205`	`197`	`= help: maybe it is overwritten before being read?`
`206`	`198`
`207`		`-warning: 25 warnings emitted`
	`199`	`+warning: 24 warnings emitted`
`208`	`200`