WIP

Author: fitzgen

src/lib.rs

@@ -67,7 +67,7 @@
 
 #![doc(html_root_url = "http://alexcrichton.com/backtrace-rs")]
 #![deny(missing_docs)]
-#![deny(warnings)]
+// #![deny(warnings)]
 
 extern crate libc;
 #[cfg(all(windows, feature = "kernel32-sys"))] extern crate kernel32;

src/symbolize/mod.rs

@@ -111,44 +111,36 @@ impl fmt::Debug for Symbol {
     }
 }
 
-// Maybe a parsed C++ symbol, if parsing the mangled symbol as Rust failed.
-#[cfg(feature = "cpp_demangle")]
-struct OptionCppSymbol<'a>(Option<::cpp_demangle::BorrowedSymbol<'a>>);
 
-#[cfg(feature = "cpp_demangle")]
-impl<'a> OptionCppSymbol<'a> {
-    fn parse(input: &'a [u8]) -> OptionCppSymbol<'a> {
-        OptionCppSymbol(::cpp_demangle::BorrowedSymbol::with_tail(input)
-                            .ok()
-                            .map(|(sym, _tail)| sym))
-    }
-
-    fn none() -> OptionCppSymbol<'a> {
-        OptionCppSymbol(None)
-    }
-
-    fn as_str(&self) -> Option<Cow<'a, str>> {
-        self.0.as_ref().map(|cpp| Cow::from(format!("{}", cpp)))
-    }
-}
+cfg_if! {
+    if #[cfg(feature = "cpp_demangle")] {
+        // Maybe a parsed C++ symbol, if parsing the mangled symbol as Rust
+        // failed.
+        struct OptionCppSymbol<'a>(Option<::cpp_demangle::BorrowedSymbol<'a>>);
 
-// Make sure to keep this zero-sized, so that the `cpp_demangle` feature has no
-// cost when disabled.
-#[cfg(not(feature = "cpp_demangle"))]
-struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
+        impl<'a> OptionCppSymbol<'a> {
+            fn parse(input: &'a [u8]) -> OptionCppSymbol<'a> {
+                OptionCppSymbol(::cpp_demangle::BorrowedSymbol::new(input).ok())
+            }
 
-#[cfg(not(feature = "cpp_demangle"))]
-impl<'a> OptionCppSymbol<'a> {
-    fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
-        OptionCppSymbol(PhantomData)
-    }
+            fn as_str(&self) -> Option<Cow<'a, str>> {
+                self.0.as_ref().map(|cpp| Cow::from(cpp.to_string()))
+            }
+        }
+    } else {
+        // Make sure to keep this zero-sized, so that the `cpp_demangle` feature
+        // has no cost when disabled.
+        struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
 
-    fn none() -> OptionCppSymbol<'a> {
-        OptionCppSymbol(PhantomData)
-    }
+        impl<'a> OptionCppSymbol<'a> {
+            fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
+                OptionCppSymbol(PhantomData)
+            }
 
-    fn as_str(&self) -> Option<Cow<'a, str>> {
-        None
+            fn as_str(&self) -> Option<Cow<'a, str>> {
+                None
+            }
+        }
     }
 }
 
@@ -165,12 +157,18 @@ impl<'a> SymbolName<'a> {
     pub fn new(bytes: &'a [u8]) -> SymbolName<'a> {
         let demangled = str::from_utf8(bytes).ok().map(demangle);
 
-        // Only try and parse a C++ symbol if we didn't parse a Rust symbol.
-        let cpp = if demangled.is_none() {
-            OptionCppSymbol::parse(bytes)
-        } else {
-            OptionCppSymbol::none()
-        };
+        // Unfortunately, rustc_demangle::Demangle doesn't expose its internal
+        // `valid` flag, so we don't know if it successfully "demangled" as a
+        // no-op on the str or not. Therefore, we have no choice but to always
+        // attempt to parse the bytes as a C++ symbol, and can't do it only as a
+        // fall back when demangling as Rust fails.
+        let cpp = OptionCppSymbol::parse(bytes);
+
+        println!("FITZGEN: bytes = {}", String::from_utf8_lossy(bytes));
+        println!("FITZGEN: cpp = {:#?}", cpp.0);
+        if let Some(ref cpp) = cpp.0 {
+            println!("FITZGEN: demangled = {}", cpp);
+        }
 
         SymbolName {
             bytes: bytes,
@@ -180,12 +178,22 @@ impl<'a> SymbolName<'a> {
     }
 
     /// Returns the raw symbol name as a `str` if the symbols is valid utf-8.
-    pub fn as_str(&self) -> Option<Cow<'a, str>> {
-        self.demangled
-            .as_ref()
-            .map(|s| Cow::from(s.as_str()))
+    ///
+    /// Will not demangle C++ symbols.
+    pub fn as_str(&self) -> Option<&'a str> {
+        self.demangled.as_ref().map(|s| s.as_str())
+    }
+
+    /// Returns the symbol name as `Cow<'a, str>` if the symbol is valid utf-8.
+    ///
+    /// Will demangle C++ symbols.
+    pub fn as_cow(&self) -> Option<Cow<'a, str>> {
+        // TODO: Next major version bump, remove the old `as_str` above, and
+        // rename this to `as_str`.
+        self.cpp_demangled
+            .as_str()
             .or_else(|| {
-                self.cpp_demangled.as_str()
+                self.demangled.as_ref().map(|s| Cow::from(s.as_str()))
             })
     }
 
@@ -195,46 +203,54 @@ impl<'a> SymbolName<'a> {
     }
 }
 
-impl<'a> fmt::Display for SymbolName<'a> {
-    #[cfg(feature = "cpp_demangle")]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if let Some(ref s) = self.demangled {
-            s.fmt(f)
-        } else if let Some(ref cpp) = self.cpp_demangled.0 {
-            cpp.fmt(f)
-        } else {
-            String::from_utf8_lossy(self.bytes).fmt(f)
+cfg_if! {
+    if #[cfg(feature = "cpp_demangle")] {
+        impl<'a> fmt::Display for SymbolName<'a> {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                if let Some(ref cpp) = self.cpp_demangled.0 {
+                    cpp.fmt(f)
+                } else if let Some(ref s) = self.demangled {
+                    s.fmt(f)
+                } else {
+                    String::from_utf8_lossy(self.bytes).fmt(f)
+                }
+            }
         }
-    }
-
-    #[cfg(not(feature = "cpp_demangle"))]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if let Some(ref s) = self.demangled {
-            s.fmt(f)
-        } else {
-            String::from_utf8_lossy(self.bytes).fmt(f)
+    } else {
+        impl<'a> fmt::Display for SymbolName<'a> {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                if let Some(ref s) = self.demangled {
+                    s.fmt(f)
+                } else {
+                    String::from_utf8_lossy(self.bytes).fmt(f)
+                }
+            }
         }
     }
 }
 
-impl<'a> fmt::Debug for SymbolName<'a> {
-    #[cfg(feature = "cpp_demangle")]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if let Some(ref s) = self.demangled {
-            s.fmt(f)
-        } else if let Some(ref cpp) = self.cpp_demangled.0 {
-            cpp.fmt(f)
-        } else {
-            String::from_utf8_lossy(self.bytes).fmt(f)
+cfg_if! {
+    if #[cfg(feature = "cpp_demangle")] {
+        impl<'a> fmt::Debug for SymbolName<'a> {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                if let Some(ref cpp) = self.cpp_demangled.0 {
+                    fmt::Display::fmt(cpp, f)
+                } else if let Some(ref s) = self.demangled {
+                    s.fmt(f)
+                } else {
+                    String::from_utf8_lossy(self.bytes).fmt(f)
+                }
+            }
         }
-    }
-
-    #[cfg(not(feature = "cpp_demangle"))]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if let Some(ref s) = self.demangled {
-            s.fmt(f)
-        } else {
-            String::from_utf8_lossy(self.bytes).fmt(f)
+    } else {
+        impl<'a> fmt::Debug for SymbolName<'a> {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                if let Some(ref s) = self.demangled {
+                    s.fmt(f)
+                } else {
+                    String::from_utf8_lossy(self.bytes).fmt(f)
+                }
+            }
         }
     }
 }

tests/smoke.rs

@@ -195,21 +195,31 @@ fn smoke_test_cpp() {
                 let mut name = None;
                 backtrace::resolve(*ip, |sym| {
                     assert!(name.is_none(), "Shouldn't have any inlined frames");
-                    name = Some(sym.name().unwrap().to_string());
+                    let sym_name = sym.name().expect("Should have a symbol name");
+                    let demangled = sym_name.as_cow()
+                        .expect("Should have a demangled form")
+                        .to_string();
+                    name = Some(demangled);
                 });
-                name.unwrap()
+                name.expect("Should have resolved the ip to a symbol")
             })
             .collect();
 
-        println!("FITZGEN: names = {:?}", names);
+        println!("actual names = {:#?}", names);
 
-        assert_eq!(names, [
+        let expected = [
             "backtrace::backtrace::trace<closure>",
             "smoke::smoke_test_cpp::assert_cpp_frames",
             "void space::templated_trampoline<void (*)()>(void (*)())",
             "cpp_trampoline",
             "smoke::smoke_test_cpp"
-        ]);
+        ];
+        println!("expected names = {:#?}", expected);
+
+        assert_eq!(names.len(), expected.len());
+        for (actual, expected) in names.iter().zip(expected.iter()) {
+            assert_eq!(actual, expected);
+        }
 
         RAN_ASSERTS.store(true, Ordering::SeqCst);
     }