add dbg! macro

firmware/qemu/src/bin/dbg.out

@@ -0,0 +1,7 @@
+TRACE x + 1 = 43
+TRACE x - 1 = 41
+INFO the answer is 41
+TRACE x - 2 = 40
+TRACE x + 2 = 44
+TRACE 
+TRACE x = 42

firmware/qemu/src/bin/dbg.release.out

@@ -0,0 +1 @@
+INFO the answer is 41

firmware/qemu/src/bin/dbg.rs

@@ -0,0 +1,42 @@
+#![no_std]
+#![no_main]
+
+use cortex_m_rt::entry;
+use cortex_m_semihosting::debug;
+
+use defmt::dbg;
+use defmt_semihosting as _; // global logger
+
+#[entry]
+fn main() -> ! {
+    // return value
+    let x: i32 = 42;
+    foo(dbg!(x + 1));
+
+    // dbg! in log statement
+    defmt::info!("the answer is {}", dbg!(x - 1));
+
+    // dbg! with multiple arguments
+    let _: (i32, i32) = dbg!(x - 2, x + 2);
+
+    // dbg! with zero arguments
+    let _: () = dbg!();
+
+    // dbg! with trailing comma
+    foo(dbg!(x,));
+
+    loop {
+        debug::exit(debug::EXIT_SUCCESS)
+    }
+}
+
+fn foo(_: i32) {}
+
+// like `panic-semihosting` but doesn't print to stdout (that would corrupt the defmt stream)
+#[cfg(target_os = "none")]
+#[panic_handler]
+fn panic(_: &core::panic::PanicInfo) -> ! {
+    loop {
+        debug::exit(debug::EXIT_FAILURE)
+    }
+}

macros/src/lib.rs

@@ -528,6 +528,46 @@ fn log(level: Level, log: FormatArgs) -> TokenStream2 {
     })
 }
 
+struct DbgArgs {
+    exprs: Punctuated<Expr, Token![,]>,
+}
+
+impl Parse for DbgArgs {
+    fn parse(input: ParseStream) -> Result<Self, syn::Error> {
+        Ok(Self {
+            exprs: Punctuated::parse_terminated(input)?,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn dbg(input: TokenStream) -> TokenStream {
+    let inputs = parse_macro_input!(input as DbgArgs).exprs;
+
+    let outputs = inputs
+        .into_iter()
+        .map(|expr| {
+            let escaped_expr = escape_expr(&expr);
+            let format_string = format!("{} = {{}}", escaped_expr);
+
+            quote!(match #expr {
+            tmp => {
+                defmt::trace!(#format_string, tmp);
+                tmp
+            }
+            })
+        })
+        .collect::<Vec<_>>();
+
+    if outputs.is_empty() {
+        // for compatibility with `std::dbg!` we also emit a TRACE log in this case
+        quote!(defmt::trace!(""))
+    } else {
+        quote!((#(#outputs),*))
+    }
+    .into()
+}
+
 #[proc_macro]
 pub fn trace(ts: TokenStream) -> TokenStream {
     log_ts(Level::Trace, ts)

src/lib.rs

@@ -219,6 +219,11 @@ pub use defmt_macros::trace;
 /// [the manual]: https://defmt.ferrous-systems.com/macros.html
 pub use defmt_macros::warn;
 
+/// Just like the [`std::dbg!`] macro but `defmt` is used to log the message at TRACE level
+///
+/// [`std::dbg!`]: https://doc.rust-lang.org/std/macro.dbg.html
+pub use defmt_macros::dbg;
+
 /// Writes formatted data to a [`Formatter`].
 ///
 /// [`Formatter`]: struct.Formatter.html

xtask/src/main.rs

@@ -245,6 +245,7 @@ fn test_snapshot() {
         "unwrap",
         "defmt-test",
         "hints",
+        "dbg",
     ];
 
     if rustc_is_nightly() {