cleanup dead_code around cpp_demangle feature

src/symbolize/mod.rs

@@ -292,32 +292,15 @@ cfg_if::cfg_if! {
                 OptionCppSymbol(None)
             }
         }
-    } else {
-        use core::marker::PhantomData;
-
-        // Make sure to keep this zero-sized, so that the `cpp_demangle` feature
-        // has no cost when disabled.
-        struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
-
-        impl<'a> OptionCppSymbol<'a> {
-            fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
-                OptionCppSymbol(PhantomData)
-            }
-
-            fn none() -> OptionCppSymbol<'a> {
-                OptionCppSymbol(PhantomData)
-            }
-        }
     }
 }
 
 /// A wrapper around a symbol name to provide ergonomic accessors to the
 /// demangled name, the raw bytes, the raw string, etc.
-// Allow dead code for when the `cpp_demangle` feature is not enabled.
-#[allow(dead_code)]
 pub struct SymbolName<'a> {
     bytes: &'a [u8],
     demangled: Option<Demangle<'a>>,
+    #[cfg(feature = "cpp_demangle")]
     cpp_demangled: OptionCppSymbol<'a>,
 }
 
@@ -327,6 +310,7 @@ impl<'a> SymbolName<'a> {
         let str_bytes = str::from_utf8(bytes).ok();
         let demangled = str_bytes.and_then(|s| try_demangle(s).ok());
 
+        #[cfg(feature = "cpp_demangle")]
         let cpp = if demangled.is_none() {
             OptionCppSymbol::parse(bytes)
         } else {
@@ -336,6 +320,7 @@ impl<'a> SymbolName<'a> {
         SymbolName {
             bytes: bytes,
             demangled: demangled,
+            #[cfg(feature = "cpp_demangle")]
             cpp_demangled: cpp,
         }
     }
@@ -380,65 +365,45 @@ fn format_symbol_name(
     Ok(())
 }
 
-cfg_if::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 s) = self.demangled {
-                    s.fmt(f)
-                } else if let Some(ref cpp) = self.cpp_demangled.0 {
-                    cpp.fmt(f)
-                } else {
-                    format_symbol_name(fmt::Display::fmt, self.bytes, f)
-                }
-            }
+impl<'a> fmt::Display for SymbolName<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ref s) = self.demangled {
+            return s.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 {
-                    format_symbol_name(fmt::Display::fmt, self.bytes, f)
-                }
+
+        #[cfg(feature = "cpp_demangle")]
+        {
+            if let Some(ref cpp) = self.cpp_demangled.0 {
+                return cpp.fmt(f);
             }
         }
+
+        format_symbol_name(fmt::Display::fmt, self.bytes, f)
     }
 }
 
-cfg_if::cfg_if! {
-    if #[cfg(all(feature = "std", feature = "cpp_demangle"))] {
-        impl<'a> fmt::Debug for SymbolName<'a> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                use std::fmt::Write;
-
-                if let Some(ref s) = self.demangled {
-                    return s.fmt(f)
-                }
-
-                // This may to print if the demangled symbol isn't actually
-                // valid, so handle the error here gracefully by not propagating
-                // it outwards.
-                if let Some(ref cpp) = self.cpp_demangled.0 {
-                    let mut s = String::new();
-                    if write!(s, "{cpp}").is_ok() {
-                        return s.fmt(f)
-                    }
-                }
-
-                format_symbol_name(fmt::Debug::fmt, self.bytes, f)
-            }
+impl<'a> fmt::Debug for SymbolName<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ref s) = self.demangled {
+            return s.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 {
-                    format_symbol_name(fmt::Debug::fmt, self.bytes, f)
+
+        #[cfg(all(feature = "std", feature = "cpp_demangle"))]
+        {
+            use std::fmt::Write;
+
+            // This may to print if the demangled symbol isn't actually
+            // valid, so handle the error here gracefully by not propagating
+            // it outwards.
+            if let Some(ref cpp) = self.cpp_demangled.0 {
+                let mut s = String::new();
+                if write!(s, "{cpp}").is_ok() {
+                    return s.fmt(f);
                 }
             }
         }
+
+        format_symbol_name(fmt::Debug::fmt, self.bytes, f)
     }
 }