Simplify AddressResult.

Author: mstange

samply-api/src/symbolicate/looked_up_addresses.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use samply_symbols::{FrameDebugInfo, SourceFilePath, SourceFilePathHandle};
+use samply_symbols::{FrameDebugInfo, SourceFilePath, SourceFilePathHandle, SymbolInfo};
 
 pub trait PathResolver {
     fn resolve_source_file_path(&self, handle: SourceFilePathHandle) -> SourceFilePath<'_>;
@@ -13,27 +13,23 @@ impl PathResolver for () {
 }
 
 pub struct AddressResult {
-    pub symbol_address: u32,
-    pub symbol_name: String,
-    pub function_size: Option<u32>,
+    pub symbol: SymbolInfo,
     pub inline_frames: Option<Vec<FrameDebugInfo>>,
 }
 
 impl AddressResult {
-    pub fn new(symbol_address: u32, symbol_name: String, function_size: Option<u32>) -> Self {
+    pub fn new(symbol: SymbolInfo) -> Self {
         Self {
-            symbol_address,
-            symbol_name,
-            function_size,
+            symbol,
             inline_frames: None,
         }
     }
 
     pub fn set_debug_info(&mut self, frames: Vec<FrameDebugInfo>) {
-        let outer_function_name = frames.last().and_then(|f| f.function.as_deref());
+        let outer_function_name = frames.last().and_then(|f| f.function.as_ref());
         // Overwrite the symbol name with the function name from the debug info.
         if let Some(name) = outer_function_name {
-            self.symbol_name = name.to_string();
+            self.symbol.name = name.clone();
         }
         // Add the inline frame info.
         self.inline_frames = Some(frames);

samply-api/src/symbolicate/mod.rs

@@ -95,21 +95,19 @@ impl<'a, H: FileAndPathHelper + 'static> SymbolicateApi<'a, H> {
         let mut external_addresses = Vec::new();
 
         for (&address, address_result) in &mut address_results {
-            if let Some(address_info) = symbol_map.lookup_sync(LookupAddress::Relative(address)) {
-                *address_result = Some(AddressResult::new(
-                    address_info.symbol.address,
-                    address_info.symbol.name,
-                    address_info.symbol.size,
-                ));
-                match address_info.frames {
-                    Some(FramesLookupResult::Available(frames)) => {
-                        address_result.as_mut().unwrap().set_debug_info(frames)
-                    }
-                    Some(FramesLookupResult::External(ext_address)) => {
-                        external_addresses.push((address, ext_address));
-                    }
-                    None => {}
+            let Some(address_info) = symbol_map.lookup_sync(LookupAddress::Relative(address))
+            else {
+                continue;
+            };
+            *address_result = Some(AddressResult::new(address_info.symbol));
+            match address_info.frames {
+                Some(FramesLookupResult::Available(frames)) => {
+                    address_result.as_mut().unwrap().set_debug_info(frames)
                 }
+                Some(FramesLookupResult::External(ext_address)) => {
+                    external_addresses.push((address, ext_address));
+                }
+                None => {}
             }
         }
 

samply-api/src/symbolicate/response_json.rs

@@ -212,12 +212,12 @@ impl<'a> serde::Serialize for ResponseFrame<'a> {
             let address_result = symbol_map.address_results.get(&frame.address).unwrap();
             // But the result might still be None.
             if let Some(address_result) = address_result {
-                map.serialize_entry("function", &address_result.symbol_name)?;
+                map.serialize_entry("function", &address_result.symbol.name)?;
                 map.serialize_entry(
                     "function_offset",
-                    &SerializeAsHexStr(frame.address - address_result.symbol_address),
+                    &SerializeAsHexStr(frame.address - address_result.symbol.address),
                 )?;
-                if let Some(function_size) = address_result.function_size {
+                if let Some(function_size) = address_result.symbol.size {
                     map.serialize_entry("function_size", &SerializeAsHexStr(function_size))?;
                 }