fix(labels): report demangled Rust names with the spacing rustc uses

src/smda/common/labelprovider/RustSymbolProvider.py

@@ -11,7 +11,6 @@
 from .ElfSymbolProvider import is_defined_elf_symbol
 from .import_parsers import resolve_pe_base_addr
 from .rust_demangler import demangle
-from .rust_demangler.utils import remove_bad_spaces
 from .RustSymbolEvidence import RUST_DEMANGLE_ERRORS, is_rust_language_evidence
 
 LOGGER = logging.getLogger(__name__)
@@ -169,7 +168,6 @@ def _update_macho(self, lief_binary, binary_info):
                 try:
                     demangled = demangle(raw_name)
                     if demangled:
-                        demangled = remove_bad_spaces(demangled)
                         self._func_symbols[adjusted] = demangled
                 except _DEMANGLE_ERRORS as exc:
                     LOGGER.debug("Failed to demangle Rust symbol %s: %s", raw_name, exc)
@@ -194,7 +192,6 @@ def _update_pe(self, lief_binary, base_addr=None):
                 if self._is_rust_symbol(raw_name):
                     demangled = demangle(raw_name)
                     if demangled:
-                        demangled = remove_bad_spaces(demangled)
                         self._func_symbols[active_base + function.address] = demangled
             except _DEMANGLE_ERRORS as exc:
                 LOGGER.debug("Failed to demangle Rust symbol %s: %s", raw_name, exc)
@@ -218,7 +215,6 @@ def _update_pe(self, lief_binary, base_addr=None):
                     if self._is_rust_symbol(raw_name):
                         demangled = demangle(raw_name)
                         if demangled:
-                            demangled = remove_bad_spaces(demangled)
                             function_offset = active_base + symbol.section.virtual_address + symbol.value
                             if function_offset not in self._func_symbols:
                                 self._func_symbols[function_offset] = demangled
@@ -239,7 +235,6 @@ def _parse_lief_symbols(self, symbols):
                     try:
                         demangled = demangle(raw_name)
                         if demangled:
-                            demangled = remove_bad_spaces(demangled)
                             function_symbols[symbol.value] = demangled
                     except _DEMANGLE_ERRORS as exc:
                         LOGGER.debug("Failed to demangle Rust symbol %s: %s", raw_name, exc)

src/smda/common/labelprovider/rust_demangler/rust_v0.py

@@ -559,7 +559,7 @@ def f1():
             if abi:
                 self.out += 'extern "'
                 self.out += "-".join(abi.split("_"))
-                self.out += '"'
+                self.out += '" '
 
             self.out += "fn("
             self.print_sep_list("print_type", ", ")

tests/testRustSymbolProvider.py

@@ -16,7 +16,6 @@
     UnableTov0Demangle,
     V0Demangler,
 )
-from smda.common.labelprovider.rust_demangler.utils import remove_bad_spaces
 from smda.common.labelprovider.RustSymbolEvidence import is_rust_language_evidence
 from smda.common.labelprovider.RustSymbolProvider import RustSymbolProvider
 
@@ -122,7 +121,7 @@ def test_v0_empty_const_hex_nibbles_raise_demangler_error(self):
     def test_v0_non_c_abi_fn_type_demangles(self):
         # the skip-pass abi validation was inverted, rejecting every valid
         # non-C abi (e.g. extern "system") fn-type symbol
-        self.assertEqual(demangle("_RIC1aFK6systemuEuE"), 'a::<extern "system"fn(())>')
+        self.assertEqual(demangle("_RIC1aFK6systemuEuE"), 'a::<extern "system" fn(())>')
 
     def test_legacy_strict_hash(self):
         """Test that hash segments are properly handled in legacy symbols."""
@@ -554,15 +553,33 @@ def test_pe_symbol_provider_returns_raw_rust_names(self):
         self.assertEqual(results[0x403000], "ExportedFunc")
 
 
-class TestUtilityFunctions(unittest.TestCase):
-    """Tests for utility functions."""
+class TestDemangledSpacing(unittest.TestCase):
+    """Demangled names reach the report spelled the way rustc spells them."""
 
-    def test_space_cleanup(self):
-        """Test remove_bad_spaces utility function."""
-        # Inner spaces removed
-        self.assertEqual(remove_bad_spaces("Vec< T >"), "Vec<T>")
-        # Separating space becomes underscore
-        self.assertEqual(remove_bad_spaces("Foo< Bar Baz >"), "Foo<Bar_Baz>")
+    # a real symbol from a rust-lld/MSVC x64 image
+    TRAIT_IMPL = "_RNvXs5_NtNtCslFVcyoAu48q_3std2io5errorNtB5_5ErrorNtNtCs55qC6OcLGgs_4core3fmt7Display3fmt"
+
+    def test_a_trait_impl_keeps_the_as_separator(self):
+        self.assertEqual(demangle(self.TRAIT_IMPL), "<std::io::error::Error as core::fmt::Display>::fmt")
+
+    def test_a_generic_argument_list_keeps_its_separating_space(self):
+        self.assertEqual(demangle("_RIC1aKh4_Kh4_E"), "a::<4, 4>")
+
+    def test_a_function_pointer_abi_is_separated_from_its_fn(self):
+        # real symbol; the space after the ABI string used to be missing
+        name = "_RNvMs3_NtCs8oYkXk2gzQW_5alloc7raw_vecINtB5_6RawVecTOhFUKCBN_EuENtNtCslFVcyoAu48q_3std5alloc6SystemE8grow_oneB13_"
+        self.assertIn('unsafe extern "C" fn(*mut u8)', demangle(name))
+
+    def test_the_provider_stores_the_name_the_demangler_produced(self):
+        provider = RustSymbolProvider(None)
+        mock_binary = MockLiefBinary([], exported_functions=[MockExport(self.TRAIT_IMPL, 0x1000)])
+        mock_binary.imagebase = 0x140000000
+        mock_binary.sections = [MockSection(0x20000000, 0x1000)]
+
+        with mock.patch("lief.PE.Binary", MockLiefBinary):
+            provider._update_pe(mock_binary, base_addr=0x400000)
+
+        self.assertEqual(provider.getSymbol(0x401000), demangle(self.TRAIT_IMPL))
 
 
 class TestRustV0ConstBackrefs(unittest.TestCase):