Implemented Debug newtypes for BacktraceFrame and BacktraceSymbol

Author: Andrew DeFilippo

src/capture.rs

@@ -1,5 +1,4 @@
-use crate::PrintFmt;
-use crate::{resolve, resolve_frame, trace, BacktraceFmt, Symbol, SymbolName};
+use crate::{resolve, resolve_frame, trace, DebugBacktraceFrame, Symbol, SymbolName};
 use std::ffi::c_void;
 use std::fmt;
 use std::path::{Path, PathBuf};
@@ -322,41 +321,18 @@ impl BacktraceSymbol {
     pub fn lineno(&self) -> Option<u32> {
         self.lineno
     }
+
+    /// Returns whether the BacktraceSymbol has any data associated with it
+    pub fn is_empty(&self) -> bool {
+        self.name.is_none() && self.addr.is_none() && self.filename.is_none() && self.lineno.is_none()
+    }
 }
 
 impl fmt::Debug for Backtrace {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let full = fmt.alternate();
-        let (frames, style) = if full {
-            (&self.frames[..], PrintFmt::Full)
-        } else {
-            (&self.frames[self.actual_start_index..], PrintFmt::Short)
-        };
-
-        // When printing paths we try to strip the cwd if it exists, otherwise
-        // we just print the path as-is. Note that we also only do this for the
-        // short format, because if it's full we presumably want to print
-        // everything.
-        let cwd = std::env::current_dir();
-        let mut print_path = move |fmt: &mut fmt::Formatter, path: crate::BytesOrWideString| {
-            let path = path.into_path_buf();
-            if !full {
-                if let Ok(cwd) = &cwd {
-                    if let Ok(suffix) = path.strip_prefix(cwd) {
-                        return fmt::Display::fmt(&suffix.display(), fmt);
-                    }
-                }
-            }
-            fmt::Display::fmt(&path.display(), fmt)
-        };
-
-        let mut f = BacktraceFmt::new(fmt, style, &mut print_path);
-        f.add_context()?;
-        for frame in frames {
-            f.frame().backtrace_frame(frame)?;
-        }
-        f.finish()?;
-        Ok(())
+        fmt.debug_list()
+            .entries(self.frames().iter().flat_map(|frame| DebugBacktraceFrame::new(frame).symbols_skip_empty()))
+            .finish()
     }
 }
 

src/lib.rs

@@ -87,7 +87,7 @@ mod types;
 pub use crate::symbolize::clear_symbol_cache;
 
 mod print;
-pub use print::{BacktraceFmt, BacktraceFrameFmt, PrintFmt};
+pub use print::{BacktraceFmt, BacktraceFrameFmt, DebugBacktraceFrame, PrintFmt};
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "std")] {

src/print.rs

@@ -7,6 +7,63 @@ const HEX_WIDTH: usize = 2 + 2 * core::mem::size_of::<usize>();
 #[cfg(target_os = "fuchsia")]
 mod fuchsia;
 
+/// A formatter for BacktraceFrames.
+pub struct DebugBacktraceFrame<'a>(&'a crate::BacktraceFrame);
+
+impl<'a> DebugBacktraceFrame<'a> {
+    #[allow(missing_docs)]
+    pub fn new(frame: &'a crate::BacktraceFrame) -> Self {
+        Self(frame)
+    }
+
+    /// Iterates over symbols in wrapped BacktraceFrame, and wraps them in DebugBacktraceSymbols.
+    pub fn symbols(&self) -> std::vec::Vec<DebugBacktraceSymbol<'a>> {
+        self.0.symbols().iter().map(DebugBacktraceSymbol::new).collect()
+    }
+
+    /// Same as symbols(), but filters out symbols that have no data
+    pub fn symbols_skip_empty(&self) -> std::vec::Vec<DebugBacktraceSymbol<'a>> {
+        self.0.symbols().iter().filter(|symbol| !symbol.is_empty()).map(DebugBacktraceSymbol::new).collect()        
+    }
+}
+
+impl<'a> fmt::Debug for DebugBacktraceFrame<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut d = f.debug_list();
+        if !self.0.symbols().is_empty() {
+            d.entries(self.0.symbols().iter().map(|symbol|  DebugBacktraceSymbol::new(symbol)));
+        }
+        d.finish()
+    }
+}
+
+/// A formatter for BacktraceSymbols.
+pub struct DebugBacktraceSymbol<'a>(&'a crate::BacktraceSymbol);
+
+impl<'a> DebugBacktraceSymbol<'a> {
+    /// Create a new DebugBacktraceSymbol.
+    pub fn new(frame: &'a crate::BacktraceSymbol) -> Self {
+        Self(frame)
+    }
+}
+
+impl<'a> fmt::Debug for DebugBacktraceSymbol<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.0.name().is_none() { return Ok(()); }
+        let mut d = f.debug_map();
+        let name = self.0.name();
+        let file = self.0
+            .filename()
+            .and_then(|p| Some(BytesOrWideString::Bytes(p.to_str()?.as_bytes())));
+        let line = self.0.lineno();
+
+        if let Some(ref name) = name { d.entry(&"function", name); }
+        if let Some(ref file) = file { d.entry(&"file", file); }
+        if let Some(ref line) = line { d.entry(&"line", line); }
+        d.finish()
+    }
+}
+
 /// A formatter for backtraces.
 ///
 /// This type can be used to print a backtrace regardless of where the backtrace