Honor symbol mappings in CLI MCP diffs

Author: HaydnTrigg

objdiff-cli/src/cmd/mcp/diff.rs

@@ -3,7 +3,7 @@
 //! These are UI-free and synchronous; the MCP server layer wraps them in
 //! `spawn_blocking` and turns the results into tool responses.
 
-use std::{fmt::Write as _, path::Path};
+use std::{collections::BTreeMap, fmt::Write as _, path::Path};
 
 use anyhow::{Context, Result};
 use objdiff_core::{
@@ -16,14 +16,20 @@ use objdiff_core::{
 ///
 /// `target` is the expected/baseline object (left); `base` is your current
 /// build (right).
-pub fn run_diff(target: &Path, base: &Path, config: &DiffObjConfig) -> Result<DiffResult> {
+pub fn run_diff(
+    target: &Path,
+    base: &Path,
+    config: &DiffObjConfig,
+    mappings: &BTreeMap<String, String>,
+) -> Result<DiffResult> {
     let target_obj = read::read(target, config, DiffSide::Target)
         .with_context(|| format!("Failed to read target object {}", target.display()))?;
     let base_obj = read::read(base, config, DiffSide::Base)
         .with_context(|| format!("Failed to read base object {}", base.display()))?;
-    let result =
-        diff_objs(Some(&target_obj), Some(&base_obj), None, config, &MappingConfig::default())
-            .context("Failed to diff objects")?;
+    let mapping_config =
+        MappingConfig { mappings: mappings.clone(), selecting_left: None, selecting_right: None };
+    let result = diff_objs(Some(&target_obj), Some(&base_obj), None, config, &mapping_config)
+        .context("Failed to diff objects")?;
     DiffResult::new(
         result.left.as_ref().map(|d| (&target_obj, d)),
         result.right.as_ref().map(|d| (&base_obj, d)),
@@ -90,11 +96,21 @@ pub fn function_diff(diff: &DiffResult, symbol: &str) -> Result<String> {
     let right = diff.right.as_ref().context("No base object in diff result")?;
     let left = diff.left.as_ref();
 
+    // Look the symbol up by its base (current) name first; fall back to the
+    // target-side name and follow its pairing back to the base symbol, so
+    // mapped symbols (e.g. statics renamed between objects) resolve either way.
     let base_sym = right
         .symbols
         .iter()
         .find(|s| s.name == symbol)
-        .with_context(|| format!("Symbol `{symbol}` not found in base (current) object"))?;
+        .or_else(|| {
+            left.and_then(|l| l.symbols.iter().find(|s| s.name == symbol))
+                .and_then(|ls| ls.target_symbol)
+                .and_then(|bi| right.symbols.get(bi as usize))
+        })
+        .with_context(|| {
+            format!("Symbol `{symbol}` not found in base (current) or target object")
+        })?;
 
     let target_sym: Option<&DiffSymbol> = base_sym
         .target_symbol

objdiff-cli/src/cmd/mcp/server.rs

@@ -165,7 +165,8 @@ impl ObjdiffServer {
             .map_err(err)?;
         let symbol = args.symbol;
         let out = tokio::task::spawn_blocking(move || -> anyhow::Result<String> {
-            let result = diff::run_diff(&inputs.target, &inputs.base, &inputs.config)?;
+            let result =
+                diff::run_diff(&inputs.target, &inputs.base, &inputs.config, &inputs.mappings)?;
             diff::function_diff(&result, &symbol)
         })
         .await
@@ -192,7 +193,8 @@ impl ObjdiffServer {
         let only = args.only_mismatches;
         let limit = args.limit.unwrap_or(200);
         let out = tokio::task::spawn_blocking(move || -> anyhow::Result<String> {
-            let result = diff::run_diff(&inputs.target, &inputs.base, &inputs.config)?;
+            let result =
+                diff::run_diff(&inputs.target, &inputs.base, &inputs.config, &inputs.mappings)?;
             Ok(diff::overview(&result, only, limit))
         })
         .await

objdiff-cli/src/cmd/mcp/state.rs

@@ -32,6 +32,8 @@ pub struct DiffInputs {
     pub target: PathBuf,
     pub base: PathBuf,
     pub config: DiffObjConfig,
+    /// Manual symbol mappings (target name -> base name) from the unit config.
+    pub mappings: BTreeMap<String, String>,
 }
 
 impl AppState {
@@ -78,13 +80,17 @@ impl AppState {
         if let Some(project) = inner.project.as_ref() {
             project.apply_options(unit, &mut config)?;
         }
+        let mappings = match (inner.project.as_ref(), unit) {
+            (Some(project), Some(unit)) => project.symbol_mappings(unit)?,
+            _ => BTreeMap::new(),
+        };
         for (key, value) in overrides {
             let id = parse_property(key)?;
             config
                 .set_property_value_str(id, value)
                 .map_err(|_| anyhow!("Invalid value `{value}` for config property `{key}`"))?;
         }
-        Ok(DiffInputs { target, base, config })
+        Ok(DiffInputs { target, base, config, mappings })
     }
 
     /// Add/remove/clear a unit's manual symbol mappings and persist them.