feat(preprod): skip renames from showing in diff (#104306)

This skips renames (same file hash, different path) from showing up in
the comparison results. A recent Xcode26 change made this way more
prominent since every compilation changes a generated UUID in app icon
image paths.

Author: trevor-e

src/sentry/preprod/size_analysis/compare.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+from typing import NamedTuple
 
 from packaging.version import InvalidVersion
 from packaging.version import parse as parse_version
@@ -10,6 +11,8 @@
     ComparisonResults,
     DiffItem,
     DiffType,
+    FileAnalysis,
+    FileInfo,
     SizeAnalysisResults,
     SizeMetricDiffItem,
     TreemapElement,
@@ -42,6 +45,11 @@ def compare_size_analysis(
 
     diff_items = []
 
+    head_renamed_paths, base_renamed_paths = _find_renamed_paths(
+        head_size_analysis_results.file_analysis,
+        base_size_analysis_results.file_analysis,
+    )
+
     if not skip_diff_item_comparison:
         for path in sorted(all_paths):
             head_elements = head_files.get(path, [])
@@ -77,6 +85,11 @@ def compare_size_analysis(
             # Process unmatched head elements (added)
             for head_element in unmatched_head:
                 head_size = head_element.size
+
+                # Skip if this is a renamed file (same hash exists in base at different path)
+                if path in head_renamed_paths:
+                    continue
+
                 if head_size == 0:
                     continue
 
@@ -94,6 +107,11 @@ def compare_size_analysis(
             # Process unmatched base elements (removed)
             for base_element in unmatched_base:
                 base_size = base_element.size
+
+                # Skip if this is a renamed file (same hash exists in head at different path)
+                if path in base_renamed_paths:
+                    continue
+
                 if base_size == 0:
                     continue
 
@@ -173,13 +191,20 @@ def _should_skip_diff_item_comparison(
     return has_mismatched_major or has_mismatched_minor
 
 
+class MatchedElements(NamedTuple):
+    """Result of matching treemap elements between head and base."""
+
+    matched_pairs: list[tuple[TreemapElement, TreemapElement]]
+    unmatched_head: list[TreemapElement]
+    unmatched_base: list[TreemapElement]
+
+
 def _match_elements(
     head_elements: list[TreemapElement], base_elements: list[TreemapElement]
-) -> tuple[list[tuple[TreemapElement, TreemapElement]], list[TreemapElement], list[TreemapElement]]:
+) -> MatchedElements:
     """
     Intelligently match elements from head and base when there are duplicates.
     For example, in iOS processing multiple images can map to the same file name.
-    Returns: (matched_pairs, unmatched_head, unmatched_base)
 
     Matching strategy:
     1. First, match by exact name and size
@@ -224,7 +249,7 @@ def _match_elements(
         elem for idx, elem in enumerate(base_elements) if idx not in matched_base_indices
     ]
 
-    return matched_pairs, unmatched_head, unmatched_base
+    return MatchedElements(matched_pairs, unmatched_head, unmatched_base)
 
 
 def _flatten_leaf_nodes(
@@ -248,3 +273,66 @@ def _flatten_leaf_nodes(
                 items[child_path].extend(child_elements)
 
     return items
+
+
+def _find_renamed_paths(
+    head_file_analysis: FileAnalysis | None,
+    base_file_analysis: FileAnalysis | None,
+) -> tuple[set[str], set[str]]:
+    """Find paths that are likely renames (same hash, different path).
+
+    When a file with the same hash exists at different paths in head vs base,
+    we consider it a rename. However, if there are more paths on one side
+    (e.g., file was renamed AND duplicated), we only mark min(head, base)
+    as renames - the rest are true additions/removals.
+    """
+    head_hash_to_paths = _build_hash_to_paths(head_file_analysis)
+    base_hash_to_paths = _build_hash_to_paths(base_file_analysis)
+
+    head_renamed_paths: set[str] = set()
+    base_renamed_paths: set[str] = set()
+
+    for file_hash, head_paths in head_hash_to_paths.items():
+        base_paths = base_hash_to_paths.get(file_hash, set())
+        # Paths only in head (not in base) with the same hash as paths only in base
+        head_only = head_paths - base_paths
+        base_only = base_paths - head_paths
+
+        if head_only and base_only:
+            # Only mark the minimum count as renames - the rest are real adds/removes
+            # e.g., 1 base path + 3 head paths = 1 rename + 2 additions
+            rename_count = min(len(head_only), len(base_only))
+            head_renamed_paths.update(sorted(head_only)[:rename_count])
+            base_renamed_paths.update(sorted(base_only)[:rename_count])
+
+    return head_renamed_paths, base_renamed_paths
+
+
+def _build_hash_to_paths(file_analysis: FileAnalysis | None) -> dict[str, set[str]]:
+    if not file_analysis:
+        return {}
+
+    hash_to_paths: dict[str, set[str]] = {}
+    for file_info in file_analysis.items:
+        _collect_file_hashes(file_info, hash_to_paths)
+    return hash_to_paths
+
+
+def _collect_file_hashes(
+    file_info: FileInfo,
+    hash_to_paths: dict[str, set[str]],
+    parent_path: str = "",
+) -> None:
+    if parent_path and not file_info.path.startswith(f"{parent_path}/"):
+        full_path = f"{parent_path}/{file_info.path}"
+    else:
+        full_path = file_info.path
+
+    if not file_info.children:
+        if file_info.hash not in hash_to_paths:
+            hash_to_paths[file_info.hash] = set()
+        hash_to_paths[file_info.hash].add(full_path)
+    else:
+        # Asset catalogs can have children
+        for child in file_info.children:
+            _collect_file_hashes(child, hash_to_paths, full_path)

src/sentry/preprod/size_analysis/models.py

@@ -8,10 +8,12 @@
 
 ###
 # Size analysis results (non-comparison)
+# Keep in sync with https://github.com/getsentry/launchpad/blob/main/src/launchpad/size/models/common.py#L92
 ###
 
 
 class TreemapElement(BaseModel):
+
     model_config = ConfigDict(frozen=True)
 
     name: str
@@ -26,12 +28,36 @@ class TreemapElement(BaseModel):
 class TreemapResults(BaseModel):
     """Complete treemap analysis results."""
 
+    model_config = ConfigDict(frozen=True)
+
     root: TreemapElement
     file_count: int
     category_breakdown: dict[str, dict[str, int]]
     platform: str
 
 
+class FileInfo(BaseModel):
+    """Slim file info for rename detection.
+
+    Only contains fields needed for hash-based rename detection.
+    Other fields (size, file_type, etc.) are available in the treemap.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    path: str
+    hash: str
+    children: list[FileInfo] = []
+
+
+class FileAnalysis(BaseModel):
+    """Analysis results for files and directories in the app bundle."""
+
+    model_config = ConfigDict(frozen=True)
+
+    items: list[FileInfo]
+
+
 class AppComponent(BaseModel):
     """Information about a modular app component (watch app, app extension, dynamic feature, etc.)."""
 
@@ -45,14 +71,17 @@ class AppComponent(BaseModel):
     install_size: int
 
 
-# Keep in sync with https://github.com/getsentry/launchpad/blob/main/src/launchpad/size/models/common.py#L92
 class SizeAnalysisResults(BaseModel):
+
+    model_config = ConfigDict(frozen=True)
+
     analysis_duration: float
     download_size: int
     install_size: int
-    treemap: TreemapResults | None
-    analysis_version: str | None
-    app_components: list[AppComponent] | None
+    treemap: TreemapResults | None = None
+    analysis_version: str | None = None
+    file_analysis: FileAnalysis | None = None
+    app_components: list[AppComponent] | None = None
 
 
 ###