DCE cleanup

.gitignore

@@ -108,3 +108,6 @@ package.tgz
 
 # AI Agents
 .claude/settings.local.json
+
+# reanalyze DCE report output
+_dce/

analysis/reactive/src/reactive.ml

@@ -15,7 +15,6 @@ type ('k, 'v) delta =
   | Batch of ('k * 'v option) list
 
 let set k v = (k, Some v)
-let remove k = (k, None)
 
 let delta_to_entries = function
   | Set (k, v) -> [(k, Some v)]
@@ -437,8 +436,6 @@ module Scheduler = struct
            !processed_nodes wave_elapsed_ms);
       propagating := false)
 
-  let wave_count () = !wave_counter
-  let reset_wave_count () = wave_counter := 0
 end
 
 (** {1 Collection Interface} *)
@@ -457,8 +454,6 @@ let iter f t = t.iter f
 let get t k = t.get k
 let length t = t.length ()
 let stats t = t.stats
-let level t = t.level
-let name t = t.name
 
 (** {1 Source Collection} *)
 

analysis/reactive/src/reactive.mli

@@ -18,12 +18,6 @@ type ('k, 'v) delta =
 val set : 'k -> 'v -> 'k * 'v option
 (** Create a batch entry that sets a key *)
 
-val remove : 'k -> 'k * 'v option
-(** Create a batch entry that removes a key *)
-
-val delta_to_entries : ('k, 'v) delta -> ('k * 'v option) list
-(** Convert delta to batch entries *)
-
 (** {1 Statistics} *)
 
 type stats = {
@@ -45,41 +39,6 @@ type stats = {
 }
 (** Per-node statistics for diagnostics *)
 
-val create_stats : unit -> stats
-
-(** {1 Node Registry} *)
-
-module Registry : sig
-  type node_info
-  (** Information about a registered node *)
-
-  val clear : unit -> unit
-  (** Clear all registered nodes *)
-
-  val to_mermaid : unit -> string
-  (** Generate a Mermaid diagram of the pipeline *)
-
-  val print_stats : unit -> unit
-  (** Print timing statistics for all nodes *)
-end
-
-(** {1 Scheduler} *)
-
-module Scheduler : sig
-  val propagate : unit -> unit
-  (** Process all dirty nodes in topological order.
-      Called automatically when a source emits. *)
-
-  val is_propagating : unit -> bool
-  (** Returns true if currently in a propagation wave *)
-
-  val wave_count : unit -> int
-  (** Number of propagation waves executed *)
-
-  val reset_wave_count : unit -> unit
-  (** Reset the wave counter *)
-end
-
 (** {1 Collection Interface} *)
 
 type ('k, 'v) t = {
@@ -97,8 +56,6 @@ val iter : ('k -> 'v -> unit) -> ('k, 'v) t -> unit
 val get : ('k, 'v) t -> 'k -> 'v option
 val length : ('k, 'v) t -> int
 val stats : ('k, 'v) t -> stats
-val level : ('k, 'v) t -> int
-val name : ('k, 'v) t -> string
 
 (** {1 Source Collection} *)
 

analysis/reactive/src/reactive_file_collection.ml

@@ -39,23 +39,6 @@ let to_collection t : (string, 'v) Reactive.t = t.collection
 (** Emit a delta *)
 let emit t delta = t.emit delta
 
-(** Process a file if changed. Emits delta to subscribers. *)
-let process_if_changed t path =
-  let new_id = get_file_id path in
-  match Hashtbl.find_opt t.internal.cache path with
-  | Some (old_id, _) when not (file_changed ~old_id ~new_id) ->
-    false (* unchanged *)
-  | _ ->
-    let raw = t.internal.read_file path in
-    let value = t.internal.process path raw in
-    Hashtbl.replace t.internal.cache path (new_id, value);
-    emit t (Reactive.Set (path, value));
-    true (* changed *)
-
-(** Process multiple files (emits individual deltas) *)
-let process_files t paths =
-  List.iter (fun path -> ignore (process_if_changed t path)) paths
-
 (** Process a file without emitting. Returns batch entry if changed. *)
 let process_file_silent t path =
   let new_id = get_file_id path in
@@ -77,11 +60,6 @@ let process_files_batch t paths =
   if entries <> [] then emit t (Reactive.Batch entries);
   List.length entries
 
-(** Remove a file *)
-let remove t path =
-  Hashtbl.remove t.internal.cache path;
-  emit t (Reactive.Remove path)
-
 (** Remove multiple files as a batch *)
 let remove_batch t paths =
   let entries =
@@ -95,17 +73,5 @@ let remove_batch t paths =
   if entries <> [] then emit t (Reactive.Batch entries);
   List.length entries
 
-(** Clear all cached data *)
-let clear t = Hashtbl.clear t.internal.cache
-
-(** Invalidate a path *)
-let invalidate t path = Hashtbl.remove t.internal.cache path
-
-let get t path =
-  match Hashtbl.find_opt t.internal.cache path with
-  | Some (_, v) -> Some v
-  | None -> None
-
 let mem t path = Hashtbl.mem t.internal.cache path
-let length t = Reactive.length t.collection
 let iter f t = Reactive.iter f t.collection

analysis/reactive/src/reactive_file_collection.mli

@@ -39,33 +39,17 @@ val to_collection : ('raw, 'v) t -> (string, 'v) Reactive.t
 
 (** {1 Processing} *)
 
-val process_files : ('raw, 'v) t -> string list -> unit
-(** Process files, emitting individual deltas for each changed file. *)
-
 val process_files_batch : ('raw, 'v) t -> string list -> int
 (** Process files, emitting a single [Batch] delta with all changes.
     Returns the number of files that changed.
     More efficient than [process_files] when processing many files at once,
     as downstream combinators can process all changes together. *)
 
-val process_if_changed : ('raw, 'v) t -> string -> bool
-(** Process a file if changed. Returns true if file was processed. *)
-
-val remove : ('raw, 'v) t -> string -> unit
-(** Remove a file from the collection. *)
-
 val remove_batch : ('raw, 'v) t -> string list -> int
 (** Remove multiple files as a batch. Returns the number of files removed.
     More efficient than calling [remove] multiple times. *)
 
-(** {1 Cache Management} *)
-
-val invalidate : ('raw, 'v) t -> string -> unit
-val clear : ('raw, 'v) t -> unit
-
 (** {1 Access} *)
 
-val get : ('raw, 'v) t -> string -> 'v option
 val mem : ('raw, 'v) t -> string -> bool
-val length : ('raw, 'v) t -> int
 val iter : (string -> 'v -> unit) -> ('raw, 'v) t -> unit

analysis/reanalyze/src/analysis_result.ml

@@ -8,15 +8,11 @@ type t = {issues: Issue.t list}
 
 let empty = {issues = []}
 
-let add_issue result issue = {issues = issue :: result.issues}
-
 let add_issues result new_issues =
   {issues = List.rev_append new_issues result.issues}
 
 let get_issues result = result.issues |> List.rev
 
-let issue_count result = List.length result.issues
-
 (** Create a dead code issue *)
 let make_dead_issue ~loc ~dead_warning ~path ~message : Issue.t =
   {

analysis/reanalyze/src/analysis_result.mli

@@ -9,18 +9,12 @@ type t
 val empty : t
 (** Empty result with no issues *)
 
-val add_issue : t -> Issue.t -> t
-(** Add a single issue to the result *)
-
 val add_issues : t -> Issue.t list -> t
 (** Add multiple issues to the result *)
 
 val get_issues : t -> Issue.t list
 (** Get all issues in order they were added *)
 
-val issue_count : t -> int
-(** Count of issues *)
-
 (** {2 Issue constructors} *)
 
 val make_dead_issue :

analysis/reanalyze/src/collect_annotations.ml

@@ -90,19 +90,17 @@ let collect_export_locations ~state ~config ~do_gentype =
              ({cd_attributes; cd_loc; cd_args} :
                Typedtree.constructor_declaration)
            ->
-             let _process_inline_records =
-               match cd_args with
-               | Cstr_record flds ->
-                 List.iter
-                   (fun ({ld_attributes; ld_loc} : Typedtree.label_declaration)
-                      ->
-                     toplevel_attrs @ cd_attributes @ ld_attributes
-                     |> process_attributes ~scope_default:!current_scope_default
-                          ~state ~config ~do_gentype:false ~name:""
-                          ~pos:ld_loc.loc_start)
-                   flds
-               | Cstr_tuple _ -> ()
-             in
+             (match cd_args with
+             | Cstr_record flds ->
+               List.iter
+                 (fun ({ld_attributes; ld_loc} : Typedtree.label_declaration)
+                    ->
+                   toplevel_attrs @ cd_attributes @ ld_attributes
+                   |> process_attributes ~scope_default:!current_scope_default
+                        ~state ~config ~do_gentype:false ~name:""
+                        ~pos:ld_loc.loc_start)
+                 flds
+             | Cstr_tuple _ -> ());
              toplevel_attrs @ cd_attributes
              |> process_attributes ~scope_default:!current_scope_default ~state
                   ~config ~do_gentype:false ~name:"" ~pos:cd_loc.loc_start)

analysis/reanalyze/src/cross_file_items_store.mli

@@ -15,13 +15,6 @@ val of_frozen : Cross_file_items.t -> t
 val of_reactive : (string, Cross_file_items.t) Reactive.t -> t
 (** Wrap reactive collection directly (no intermediate collection) *)
 
-val iter_optional_arg_calls :
-  t -> (Cross_file_items.optional_arg_call -> unit) -> unit
-(** Iterate over all optional arg calls *)
-
-val iter_function_refs : t -> (Cross_file_items.function_ref -> unit) -> unit
-(** Iterate over all function refs *)
-
 val compute_optional_args_state :
   t ->
   find_decl:(Lexing.position -> Decl.t option) ->