Fix package_id_to_targets not cleaned during target removal

Summary:
remove_target and remove_targets_batch leave dangling entries in
package_id_to_targets when targets are removed from the graph. This means
the package-to-target mapping accumulates stale target IDs over time,
which corrupts serialized graphs via --output-graph and prevents us from
using package_id_to_targets as a reliable source of truth for removal
detection.

For batch removal, iterate package_id_to_targets and retain only targets
not in the removal set. For single removal, scan package_id_to_targets
to find and remove the target from its package.

Reviewed By: aniketmathur

Differential Revision: D95091082

fbshipit-source-id: 3c46abd433bcd03c9e638aa0c86eb446a3e0be03

Author: Aaron Ho

td_util/src/buck/target_graph.rs

@@ -409,6 +409,7 @@ impl TargetGraph {
             self.remove_regular_target(target_id);
         }
 
+        self.remove_target_from_package(target_id);
         self.target_id_to_deps.remove(&target_id);
         self.target_id_to_ci_srcs.remove(&target_id);
         self.target_id_to_ci_srcs_must_match.remove(&target_id);
@@ -420,6 +421,22 @@ impl TargetGraph {
         self.minimized_targets.remove(&target_id);
     }
 
+    fn remove_target_from_package(&self, target_id: TargetId) {
+        for mut entry in self.package_id_to_targets.iter_mut() {
+            let targets = entry.value_mut();
+            let Some(pos) = targets.iter().position(|&id| id == target_id) else {
+                continue;
+            };
+            targets.swap_remove(pos);
+            if targets.is_empty() {
+                let package_id = *entry.key();
+                drop(entry);
+                self.package_id_to_targets.remove(&package_id);
+            }
+            return;
+        }
+    }
+
     fn remove_ci_hint_target(&self, target_id: TargetId) {
         // Clean up CI hint edges from dedicated maps
         if let Some(affected) = self.get_ci_hint_affected(target_id) {
@@ -464,6 +481,7 @@ impl TargetGraph {
 
         self.clean_ci_hint_edges_for_removed_targets(targets_to_remove);
         self.clean_rdeps_for_removed_targets(targets_to_remove);
+        self.clean_package_targets_for_removed_targets(targets_to_remove);
         self.clean_per_target_data(targets_to_remove);
     }
 
@@ -508,6 +526,13 @@ impl TargetGraph {
         });
     }
 
+    fn clean_package_targets_for_removed_targets(&self, targets_to_remove: &HashSet<TargetId>) {
+        self.package_id_to_targets.retain(|_, targets| {
+            targets.retain(|id| !targets_to_remove.contains(id));
+            !targets.is_empty()
+        });
+    }
+
     fn clean_per_target_data(&self, targets_to_remove: &HashSet<TargetId>) {
         for &target_id in targets_to_remove {
             self.target_id_to_deps.remove(&target_id);
@@ -1614,4 +1639,75 @@ mod tests {
 
         assert!(graph.get_minimized_target(target).is_some());
     }
+
+    #[test]
+    fn batch_remove_cleans_package_id_to_targets() {
+        let graph = TargetGraph::new();
+
+        let package_id = graph.store_package("fbcode//pkg");
+        let target_a = graph.store_target("fbcode//pkg:a");
+        let target_b = graph.store_target("fbcode//pkg:b");
+        let survivor = graph.store_target("fbcode//pkg:survivor");
+
+        graph.add_target_to_package(package_id, target_a);
+        graph.add_target_to_package(package_id, target_b);
+        graph.add_target_to_package(package_id, survivor);
+
+        for &id in &[target_a, target_b, survivor] {
+            store_minimized_stub(&graph, id);
+        }
+
+        let to_remove: HashSet<TargetId> = [target_a, target_b].into_iter().collect();
+        graph.remove_targets_batch(&to_remove);
+
+        let remaining = graph.get_targets_in_package(package_id).unwrap();
+        assert_eq!(remaining, vec![survivor]);
+    }
+
+    #[test]
+    fn batch_remove_cleans_package_id_to_targets_across_packages() {
+        let graph = TargetGraph::new();
+
+        let pkg1 = graph.store_package("fbcode//pkg1");
+        let pkg2 = graph.store_package("fbcode//pkg2");
+        let target_a = graph.store_target("fbcode//pkg1:a");
+        let target_b = graph.store_target("fbcode//pkg2:b");
+        let survivor = graph.store_target("fbcode//pkg2:survivor");
+
+        graph.add_target_to_package(pkg1, target_a);
+        graph.add_target_to_package(pkg2, target_b);
+        graph.add_target_to_package(pkg2, survivor);
+
+        for &id in &[target_a, target_b, survivor] {
+            store_minimized_stub(&graph, id);
+        }
+
+        let to_remove: HashSet<TargetId> = [target_a, target_b].into_iter().collect();
+        graph.remove_targets_batch(&to_remove);
+
+        assert!(graph.get_targets_in_package(pkg1).is_none());
+        let remaining = graph.get_targets_in_package(pkg2).unwrap();
+        assert_eq!(remaining, vec![survivor]);
+    }
+
+    #[test]
+    fn remove_target_cleans_package_id_to_targets() {
+        let graph = TargetGraph::new();
+
+        let package_id = graph.store_package("fbcode//pkg");
+        let target_a = graph.store_target("fbcode//pkg:a");
+        let target_b = graph.store_target("fbcode//pkg:b");
+
+        graph.add_target_to_package(package_id, target_a);
+        graph.add_target_to_package(package_id, target_b);
+
+        for &id in &[target_a, target_b] {
+            store_minimized_stub(&graph, id);
+        }
+
+        graph.remove_target(target_a);
+
+        let remaining = graph.get_targets_in_package(package_id).unwrap();
+        assert_eq!(remaining, vec![target_b]);
+    }
 }