fix: honor platform filter in cross-reference

scripts/cross_reference.py

@@ -36,11 +36,15 @@ DEFAULT_DB = "database.json"
 
 def load_platform_files(
     platforms_dir: str,
+    platforms: list[str] | None = None,
 ) -> tuple[dict[str, set[str]], dict[str, set[str]]]:
-    """Load all platform configs and collect declared filenames + data_directories per system."""
+    """Collect declared filenames + data_directories per system.
+
+    Restricted to *platforms* when given, otherwise every registered platform.
+    """
     declared = {}
     platform_data_dirs = {}
-    for platform_name in list_registered_platforms(
+    for platform_name in platforms or list_registered_platforms(
         platforms_dir, include_archived=True
     ):
         config = load_platform_config(platform_name, platforms_dir)
@@ -415,7 +419,7 @@ def main():
     parser.add_argument("--db", default=DEFAULT_DB)
     parser.add_argument("--emulator", "-e", help="Analyze single emulator")
     parser.add_argument(
-        "--platform", "-p", help="Platform name (required for --target)"
+        "--platform", "-p", help="Restrict analysis to one platform's cores"
     )
     parser.add_argument("--target", "-t", help="Hardware target (e.g., switch, rpi4)")
     parser.add_argument("--json", action="store_true", help="JSON output")
@@ -425,13 +429,16 @@ def main():
     if args.emulator:
         profiles = {k: v for k, v in profiles.items() if k == args.emulator}
 
-    if args.target:
-        if not args.platform:
-            parser.error("--target requires --platform")
+    if args.target and not args.platform:
+        parser.error("--target requires --platform")
+
+    if args.platform:
         from common import load_target_config, resolve_platform_cores
 
-        target_cores = load_target_config(
-            args.platform, args.target, args.platforms_dir
+        target_cores = (
+            load_target_config(args.platform, args.target, args.platforms_dir)
+            if args.target
+            else None
         )
         config = load_platform_config(args.platform, args.platforms_dir)
         relevant = resolve_platform_cores(config, profiles, target_cores=target_cores)
@@ -441,7 +448,9 @@ def main():
         print("No emulator profiles found.", file=sys.stderr)
         return
 
-    declared, plat_data_dirs = load_platform_files(args.platforms_dir)
+    declared, plat_data_dirs = load_platform_files(
+        args.platforms_dir, [args.platform] if args.platform else None
+    )
     db = load_database(args.db)
     data_names = _build_supplemental_index()
     report = cross_reference(profiles, declared, db, plat_data_dirs, data_names)

tests/test_e2e.py

@@ -5147,6 +5147,36 @@ struct BurnDriver BurnDrvneogeo = {
         self.assertEqual(len(systems), len(set(systems)))
 
 
+    def test_226_cross_reference_platform_filter(self):
+        """--platform restricts declarations to that platform alone."""
+        from cross_reference import load_platform_files
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            plat_dir = os.path.join(tmpdir, "platforms")
+            os.makedirs(plat_dir)
+            registry = {
+                "platforms": {
+                    "alpha": {"status": "active"},
+                    "beta": {"status": "active"},
+                }
+            }
+            with open(os.path.join(plat_dir, "_registry.yml"), "w") as f:
+                yaml.dump(registry, f)
+            for name, fname in (("alpha", "a.bin"), ("beta", "b.bin")):
+                cfg = {
+                    "platform": name,
+                    "verification_mode": "md5",
+                    "systems": {"shared-system": {"files": [{"name": fname}]}},
+                }
+                with open(os.path.join(plat_dir, f"{name}.yml"), "w") as f:
+                    yaml.dump(cfg, f)
+
+            everything, _ = load_platform_files(plat_dir)
+            self.assertEqual(everything["shared-system"], {"a.bin", "b.bin"})
+
+            only_alpha, _ = load_platform_files(plat_dir, ["alpha"])
+            self.assertEqual(only_alpha["shared-system"], {"a.bin"})
+
 
 if __name__ == "__main__":
     unittest.main()