metrics: handle distinct refs resolving to the same SHA in diff (#10429)

`dvc metrics diff --all <a> <b>` returned `{}` when `a` and `b` were
distinct ref names that pointed at the same commit (e.g. `main` and
`HEAD`). The brancher groups same-SHA revisions under a single
comma-joined composite key (e.g. `"main,HEAD"`), but `_diff()` looked
each rev up by exact key, missed the composite, and produced an empty
result instead of an all-zero diff.

Fall back to membership lookup when the direct key isn't present. This
also implicitly fixes `dvc params diff --all <a> <b>`, which delegates
to the same `_diff` helper.

Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: jbbqqf

dvc/repo/metrics/diff.py

@@ -16,14 +16,29 @@ class DiffResult(TypedDict, total=False):
     diff: dict[str, dict[str, dict]]
 
 
+def _resolve_rev(result: dict[str, "Result"], rev: str) -> "Result":
+    # Direct hit when brancher emitted this rev as its own key.
+    if rev in result:
+        return result[rev]
+    # Brancher groups revisions resolving to the same SHA under a single
+    # comma-joined composite key (e.g. "main,HEAD" when both resolve to the
+    # same commit). Fall back to lookup by membership so callers passing two
+    # distinct ref names that happen to point at the same commit still get a
+    # result. See https://github.com/iterative/dvc/issues/10429.
+    for key, value in result.items():
+        if rev in key.split(","):
+            return value
+    return {}
+
+
 def _diff(
     result: dict[str, "Result"],
     old_rev: str,
     new_rev: str,
     **kwargs,
 ) -> DiffResult:
-    old = result.get(old_rev, {})
-    new = result.get(new_rev, {})
+    old = _resolve_rev(result, old_rev)
+    new = _resolve_rev(result, new_rev)
 
     old_data = old.get("data", {})
     new_data = new.get("data", {})

tests/func/metrics/test_diff.py

@@ -9,6 +9,26 @@
 from dvc.utils.serialize import JSONFileCorruptedError
 
 
+def test_metrics_diff_same_commit_different_refs(tmp_dir, scm, dvc, run_copy_metrics):
+    # Regression for https://github.com/iterative/dvc/issues/10429.
+    # When a_rev and b_rev are distinct ref names that happen to resolve to the
+    # same SHA (e.g. "main" and "HEAD"), brancher groups them under a single
+    # composite key like "main,HEAD" in the metrics.show() result. The old
+    # _diff() looked up "main" and "HEAD" individually and returned {}; the
+    # expected behavior is an all-zero diff (same metrics on both sides).
+    tmp_dir.gen({"m_temp.yaml": "1"})
+    run_copy_metrics("m_temp.yaml", "m.yaml", name="copy-metrics", metrics=["m.yaml"])
+    dvc.scm.commit("add metrics")
+
+    branch_name = scm.active_branch()
+    expected = {"m.yaml": {"": {"old": 1, "new": 1, "diff": 0}}}
+
+    # both ref names resolve to the same SHA -> diff should still report all-zero
+    assert dvc.metrics.diff(a_rev=branch_name, b_rev="HEAD", all=True) == {
+        "diff": expected
+    }
+
+
 def test_metrics_diff_simple(tmp_dir, scm, dvc, run_copy_metrics):
     def _gen(val):
         tmp_dir.gen({"m_temp.yaml": str(val)})