Use destructuring for format strings

Author: geofft

crates/uv/src/windows_exception.rs

@@ -125,91 +125,111 @@ fn display_exception_info(
 
 #[cfg(target_arch = "x86")]
 fn dump_regs(e: &mut ExceptionSafeStderr, c: &CONTEXT) -> std::fmt::Result {
+    let CONTEXT {
+        Eax,
+        Ebx,
+        Ecx,
+        Edx,
+        Esi,
+        Edi,
+        Eip,
+        Ebp,
+        Esp,
+        EFlags,
+        ..
+    } = c;
     writeln!(
         e,
-        "eax={:08x} ebx={:08x} ecx={:08x} edx={:08x} esi={:08x} edi={:08x}",
-        c.Eax, c.Ebx, c.Ecx, c.Edx, c.Esi, c.Edi
+        "eax={Eax:08x} ebx={Ebx:08x} ecx={Ecx:08x} edx={Edx:08x} esi={Esi:08x} edi={Edi:08x}"
     )?;
     writeln!(
         e,
-        "eip={:08x} ebp={:08x} esp={:08x} eflags={:08x}",
-        c.Eip, c.Ebp, c.Esp, c.EFlags
+        "eip={Eip:08x} ebp={Ebp:08x} esp={Esp:08x} eflags={EFlags:08x}"
     )?;
-    Ok(())
 }
 
 #[cfg(target_arch = "x86_64")]
 fn dump_regs(e: &mut ExceptionSafeStderr, c: &CONTEXT) -> std::fmt::Result {
-    writeln!(
-        e,
-        "rax={:016x} rbx={:016x} rcx={:016x}",
-        c.Rax, c.Rbx, c.Rcx
-    )?;
-    writeln!(
-        e,
-        "rdx={:016x} rsi={:016x} rdi={:016x}",
-        c.Rdx, c.Rsi, c.Rdi
-    )?;
-    writeln!(e, "rsp={:016x} rbp={:016x}  r8={:016x}", c.Rsp, c.Rbp, c.R8)?;
-    writeln!(e, " r9={:016x} r10={:016x} r11={:016x}", c.R9, c.R10, c.R11)?;
-    writeln!(
-        e,
-        "r12={:016x} r13={:016x} r14={:016x}",
-        c.R12, c.R13, c.R14
-    )?;
-    writeln!(
-        e,
-        "r15={:016x} rip={:016x} eflags={:016x}",
-        c.R15, c.Rip, c.EFlags
-    )?;
+    let CONTEXT {
+        Rax,
+        Rbx,
+        Rcx,
+        Rdx,
+        Rsi,
+        Rdi,
+        Rsp,
+        Rbp,
+        R8,
+        R9,
+        R10,
+        R11,
+        R12,
+        R13,
+        R14,
+        R15,
+        Rip,
+        EFlags,
+        ..
+    } = c;
+    writeln!(e, "rax={Rax:016x} rbx={Rbx:016x} rcx={Rcx:016x}")?;
+    writeln!(e, "rdx={Rdx:016x} rsi={Rsi:016x} rdi={Rdi:016x}")?;
+    writeln!(e, "rsp={Rsp:016x} rbp={Rbp:016x}  r8={R8 :016x}")?;
+    writeln!(e, " r9={R9 :016x} r10={R10:016x} r11={R11:016x}")?;
+    writeln!(e, "r12={R12:016x} r13={R13:016x} r14={R14:016x}")?;
+    writeln!(e, "r15={R15:016x} rip={Rip:016x} eflags={EFlags:016x}")?;
     Ok(())
 }
 
 #[cfg(target_arch = "aarch64")]
 fn dump_regs(e: &mut ExceptionSafeStderr, c: &CONTEXT) -> std::fmt::Result {
+    let CONTEXT { Cpsr, Sp, Pc, .. } = c;
     // SAFETY: The two variants of this anonymous union are equivalent,
     // one's an array and one has named registers.
-    let r = unsafe { c.Anonymous.Anonymous };
-    writeln!(
-        e,
-        "cpsr={:016x}  sp={:016x}  pc={:016x}",
-        c.Cpsr, c.Sp, c.Pc
-    )?;
-    writeln!(e, "  x0={:016x}  x1={:016x}  x2={:016x}", r.X0, r.X1, r.X2)?;
-    writeln!(e, "  x3={:016x}  x4={:016x}  x5={:016x}", r.X3, r.X4, r.X5)?;
-    writeln!(e, "  x6={:016x}  x7={:016x}  x8={:016x}", r.X6, r.X7, r.X8)?;
-    writeln!(
-        e,
-        "  x9={:016x} x10={:016x} x11={:016x}",
-        r.X9, r.X10, r.X11
-    )?;
-    writeln!(
-        e,
-        " x12={:016x} x13={:016x} x14={:016x}",
-        r.X12, r.X13, r.X14
-    )?;
-    writeln!(
-        e,
-        " x15={:016x} x16={:016x} x17={:016x}",
-        r.X15, r.X16, r.X17
-    )?;
-    writeln!(
-        e,
-        " x18={:016x} x19={:016x} x20={:016x}",
-        r.X18, r.X19, r.X20
-    )?;
-    writeln!(
-        e,
-        " x21={:016x} x22={:016x} x23={:016x}",
-        r.X21, r.X22, r.X23
-    )?;
-    writeln!(
-        e,
-        " x24={:016x} x25={:016x} x26={:016x}",
-        r.X24, r.X25, r.X26
-    )?;
-    writeln!(e, " x27={:016x} x28={:016x}", r.X27, r.X28)?;
-    writeln!(e, "  fp={:016x}  lr={:016x}", r.Fp, r.Lr)?;
+    let regs = unsafe { c.Anonymous.Anonymous };
+    let Windows::Win32::System::Diagnostics::Debug::CONTEXT_0_0 {
+        X0,
+        X1,
+        X2,
+        X3,
+        X4,
+        X5,
+        X6,
+        X7,
+        X8,
+        X9,
+        X10,
+        X11,
+        X12,
+        X13,
+        X14,
+        X15,
+        X16,
+        X17,
+        X18,
+        X19,
+        X20,
+        X21,
+        X22,
+        X23,
+        X24,
+        X25,
+        X26,
+        X27,
+        X28,
+        Fp,
+        Lr,
+    } = regs;
+    writeln!(e, "cpsr={Cpsr:016x}  sp={Sp :016x}  pc={Pc :016x}")?;
+    writeln!(e, "  x0={X0  :016x}  x1={X1 :016x}  x2={X2 :016x}")?;
+    writeln!(e, "  x3={X3  :016x}  x4={X4 :016x}  x5={X5 :016x}")?;
+    writeln!(e, "  x6={X6  :016x}  x7={X7 :016x}  x8={X8 :016x}")?;
+    writeln!(e, "  x9={X9  :016x} x10={X10:016x} x11={X11:016x}")?;
+    writeln!(e, " x12={X12 :016x} x13={X13:016x} x14={X14:016x}")?;
+    writeln!(e, " x15={X15 :016x} x16={X16:016x} x17={X17:016x}")?;
+    writeln!(e, " x18={X18 :016x} x19={X19:016x} x20={X20:016x}")?;
+    writeln!(e, " x21={X21 :016x} x22={X22:016x} x23={X23:016x}")?;
+    writeln!(e, " x24={X24 :016x} x25={X25:016x} x26={X26:016x}")?;
+    writeln!(e, "  fp={Fp  :016x}  lr={Lr :016x}")?;
     Ok(())
 }