Make issues_by_file reactive

- issues_by_file is now a reactive flatMap from dead_decls_by_file
- Per-file issue generation with shouldReport callback (no mutations)
- Module issues generated separately from dead_modules + modules_with_reported_values
- Correctly handles flatMap not tracking reads from other collections

Timing improvement on benchmark (cache hit):
- iter_issues: ~1.5ms (down from ~32ms)
- iter_modules: ~5-7ms (new, iterates dead_modules)
- Total dead_code: ~12-14ms (down from ~38-40ms)

All 380/19000 issues still match between reactive and non-reactive modes.

Author: cristianoc

analysis/reanalyze/src/ReactiveSolver.ml

@@ -1,19 +1,19 @@
 (** Reactive dead code solver.
     
-    Reactive pipeline: decls + live → dead_decls, live_decls, dead_modules, dead_decls_by_file
+    Reactive pipeline: decls + live → dead_decls, live_decls, dead_modules, dead_decls_by_file, issues_by_file
     
     Current status:
-    - dead_decls, live_decls, dead_modules, dead_decls_by_file are all reactive
+    - All collections are reactive (zero recomputation on cache hit for unchanged files)
+    - dead_decls, live_decls = decls partitioned by liveness (reactive join)
     - dead_modules = modules with dead decls but no live decls (reactive anti-join)
     - dead_decls_by_file = dead decls grouped by file (reactive flatMap with merge)
+    - issues_by_file = per-file issue generation (reactive flatMap)
     - is_pos_live uses reactive live collection (no resolvedDead mutation)
     - shouldReport callback replaces report field mutation (no mutation needed)
-    - Per-file issue generation using reactive dead_decls_by_file
     - isInsideReportedValue is per-file only, so files are independent
+    - Module issues generated in collect_issues from dead_modules + modules_with_reported_values
     
-    TODO for fully reactive issues:
-    - Make per-file issues a reactive collection (issues_by_file)
-      Currently we iterate dead_decls_by_file to generate issues
+    TODO for further optimization:
     - hasRefBelow: uses O(total_refs) linear scan of refs_from per dead decl;
       could use reactive refs_to index for O(1) lookup per decl
     
@@ -33,6 +33,11 @@ type t = {
       (** Modules where all declarations are dead. Reactive anti-join. *)
   dead_decls_by_file: (string, Decl.t list) Reactive.t;
       (** Dead declarations grouped by file. Reactive per-file grouping. *)
+  issues_by_file: (string, Issue.t list * Name.t list) Reactive.t;
+      (** Dead code issues grouped by file. Reactive per-file issue generation.
+          First component: value/type/exception issues.
+          Second component: modules with at least one reported value (for module issue generation). *)
+  config: DceConfig.t;
 }
 
 (** Extract module name from a declaration *)
@@ -103,7 +108,53 @@ let create ~(decls : (Lexing.position, Decl.t) Reactive.t)
       ()
   in
 
-  {decls; live; dead_decls; live_decls; annotations; value_refs_from; dead_modules; dead_decls_by_file}
+  (* hasRefBelow callback - captured once, uses current state of value_refs_from *)
+  let transitive = config.DceConfig.run.transitive in
+  let hasRefBelow =
+    match value_refs_from with
+    | None -> fun _ -> false
+    | Some refs_from ->
+      DeadCommon.make_hasRefBelow ~transitive ~iter_value_refs_from:(fun f ->
+          Reactive.iter f refs_from)
+  in
+
+  (* Reactive per-file issues - recomputed when dead_decls_by_file changes.
+     Returns (file, (value_issues, modules_with_reported_values)) where
+     modules_with_reported_values are modules that have at least one reported dead value.
+     Module issues are generated separately in collect_issues using dead_modules. *)
+  let issues_by_file =
+    Reactive.flatMap dead_decls_by_file
+      ~f:(fun file decls ->
+        (* Track modules that have reported values *)
+        let modules_with_values : (Name.t, unit) Hashtbl.t = Hashtbl.create 8 in
+        (* shouldReport checks annotations reactively *)
+        let shouldReport (decl : Decl.t) =
+          match Reactive.get annotations decl.pos with
+          | Some FileAnnotations.Live -> false
+          | Some FileAnnotations.GenType -> false
+          | Some FileAnnotations.Dead -> false
+          | None -> true
+        in
+        (* Don't emit module issues here - track modules for later *)
+        let checkModuleDead ~fileName:_ moduleName =
+          Hashtbl.replace modules_with_values moduleName ();
+          None (* Module issues generated separately *)
+        in
+        (* Sort within file and generate issues *)
+        let sorted = decls |> List.fast_sort Decl.compareForReporting in
+        let reporting_ctx = DeadCommon.ReportingContext.create () in
+        let file_issues =
+          sorted
+          |> List.concat_map (fun decl ->
+                 DeadCommon.reportDeclaration ~config ~hasRefBelow ~checkModuleDead
+                   ~shouldReport reporting_ctx decl)
+        in
+        let modules_list = Hashtbl.fold (fun m () acc -> m :: acc) modules_with_values [] in
+        [(file, (file_issues, modules_list))])
+      ()
+  in
+
+  {decls; live; dead_decls; live_decls; annotations; value_refs_from; dead_modules; dead_decls_by_file; issues_by_file; config}
 
 (** Check if a module is dead using reactive collection. Returns issue if dead.
     Uses reported_modules set to avoid duplicate reports. *)
@@ -126,13 +177,14 @@ let check_module_dead ~(dead_modules : (Name.t, Location.t) Reactive.t)
       Some (AnalysisResult.make_dead_module_issue ~loc ~moduleName)
     | None -> None
 
-(** Collect issues from dead and live declarations.
-    Uses reactive dead_modules instead of mutable DeadModules.
-    O(dead_decls + live_decls), not O(all_decls). *)
+(** Collect issues from reactive issues_by_file.
+    Only iterates the pre-computed reactive issues collection.
+    Deduplicates module issues across files. *)
 let collect_issues ~(t : t) ~(config : DceConfig.t)
     ~(ann_store : AnnotationStore.t) : Issue.t list =
+  ignore config; (* config is stored in t *)
   let t0 = Unix.gettimeofday () in
-  (* Track reported modules to avoid duplicates *)
+  (* Track reported modules to avoid duplicates across files *)
   let reported_modules = Hashtbl.create 64 in
 
   (* Check live declarations for incorrect @dead *)
@@ -155,59 +207,53 @@ let collect_issues ~(t : t) ~(config : DceConfig.t)
     t.live_decls;
   let t1 = Unix.gettimeofday () in
 
-  (* Generate issues per-file using reactive dead_decls_by_file.
-     isInsideReportedValue only checks within same file, so files are independent. *)
-  let transitive = config.DceConfig.run.transitive in
-  let hasRefBelow =
-    match t.value_refs_from with
-    | None -> fun _ -> false
-    | Some refs_from ->
-      DeadCommon.make_hasRefBelow ~transitive ~iter_value_refs_from:(fun f ->
-          Reactive.iter f refs_from)
-  in
-  (* Callback for checking dead modules using reactive collection *)
-  let checkModuleDead ~fileName moduleName =
-    check_module_dead ~dead_modules:t.dead_modules ~reported_modules ~fileName
-      moduleName
-  in
-  (* Callback to check if we should report a dead decl (no mutation) *)
-  let shouldReport (decl : Decl.t) =
-    match Reactive.get t.annotations decl.pos with
-    | Some FileAnnotations.Live -> false
-    | Some FileAnnotations.GenType -> false
-    | Some FileAnnotations.Dead -> false (* @dead = user knows, don't warn *)
-    | None -> true
-  in
+  (* Collect issues from reactive issues_by_file *)
   let num_files = ref 0 in
-  let dead_issues =
-    let issues = ref [] in
-    Reactive.iter
-      (fun _file decls ->
-        incr num_files;
-        (* Sort within file for isInsideReportedValue - pass ALL decls for correct context *)
-        let sorted = decls |> List.fast_sort Decl.compareForReporting in
-        (* Fresh ReportingContext per file *)
-        let reporting_ctx = DeadCommon.ReportingContext.create () in
-        let file_issues =
-          sorted
-          |> List.concat_map (fun decl ->
-                 DeadCommon.reportDeclaration ~config ~hasRefBelow ~checkModuleDead
-                   ~shouldReport reporting_ctx decl)
-        in
-        issues := file_issues @ !issues)
-      t.dead_decls_by_file;
-    !issues
-  in
+  let dead_issues = ref [] in
+  (* Track modules that have at least one reported value (for module issue generation) *)
+  let modules_with_reported_values : (Name.t, unit) Hashtbl.t = Hashtbl.create 64 in
+  Reactive.iter
+    (fun _file (file_issues, modules_list) ->
+      incr num_files;
+      dead_issues := file_issues @ !dead_issues;
+      (* Collect modules that have reported values *)
+      List.iter
+        (fun moduleName -> Hashtbl.replace modules_with_reported_values moduleName ())
+        modules_list)
+    t.issues_by_file;
   let t2 = Unix.gettimeofday () in
 
+  (* Generate module issues: only for modules that are dead AND have a reported value *)
+  let module_issues = ref [] in
+  let reported_modules : (Name.t, unit) Hashtbl.t = Hashtbl.create 64 in
+  Reactive.iter
+    (fun moduleName loc ->
+      (* Only report if module has at least one reported dead value *)
+      if Hashtbl.mem modules_with_reported_values moduleName then
+        if not (Hashtbl.mem reported_modules moduleName) then (
+          Hashtbl.replace reported_modules moduleName ();
+          let loc =
+            if loc.Location.loc_ghost then
+              let pos_fname = loc.loc_start.pos_fname in
+              let pos =
+                {Lexing.pos_fname; pos_lnum = 0; pos_bol = 0; pos_cnum = 0}
+              in
+              {Location.loc_start = pos; loc_end = pos; loc_ghost = false}
+            else loc
+          in
+          module_issues := AnalysisResult.make_dead_module_issue ~loc ~moduleName :: !module_issues))
+    t.dead_modules;
+  let t3 = Unix.gettimeofday () in
+
   if !Cli.timing then
     Printf.eprintf
-      "    collect_issues: iter_live=%.2fms per_file=%.2fms (%d files)\n"
+      "    collect_issues: iter_live=%.2fms iter_issues=%.2fms iter_modules=%.2fms (%d files)\n"
       ((t1 -. t0) *. 1000.0)
       ((t2 -. t1) *. 1000.0)
+      ((t3 -. t2) *. 1000.0)
       !num_files;
 
-  List.rev !incorrect_dead_issues @ dead_issues
+  List.rev !incorrect_dead_issues @ !module_issues @ !dead_issues
 
 (** Iterate over live declarations *)
 let iter_live_decls ~(t : t) (f : Decl.t -> unit) : unit =