refactor(reanalyze): remove Common.ml kitchen sink module

Extract focused modules from Common.ml:
- Cli.ml: CLI option refs
- Pos.ml: Position utilities
- PosSet.ml, PosHash.ml: Position collections
- StringSet.ml, FileSet.ml, FileHash.ml: String/file collections
- DcePath.ml: Dead code path type (renamed from Path to avoid shadowing)
- Decl.ml: Declaration types (Kind, t, posAdjustment)
- Issue.ml: Issue types (severity, deadWarning, description, etc.)
- LocSet.ml: Location set
- OptionalArgs.ml, OptionalArgsState.ml: Optional args tracking

This eliminates the Common.ml 'kitchen sink' that was causing:
- Circular dependency issues
- Poor code organization
- Difficulty understanding module boundaries

Each module now has a single responsibility.

Signed-Off-By: Cristiano Calcagno

Author: cristianoc

analysis/reanalyze/src/AnalysisResult.ml

@@ -3,9 +3,7 @@
     The solver returns this instead of logging directly.
     All side effects (logging, JSON output) happen in the reporting phase. *)
 
-open Common
-
-type t = {issues: issue list}
+type t = {issues: Issue.t list}
 (** Immutable analysis result *)
 
 let empty = {issues = []}
@@ -20,11 +18,11 @@ 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 ~deadWarning ~path ~message =
+let make_dead_issue ~loc ~deadWarning ~path ~message : Issue.t =
   {
-    name =
+    Issue.name =
       (match deadWarning with
-      | WarningDeadException -> "Warning Dead Exception"
+      | Issue.WarningDeadException -> "Warning Dead Exception"
       | WarningDeadType -> "Warning Dead Type"
       | WarningDeadValue -> "Warning Dead Value"
       | WarningDeadValueWithSideEffects ->
@@ -36,9 +34,9 @@ let make_dead_issue ~loc ~deadWarning ~path ~message =
   }
 
 (** Create a dead module issue *)
-let make_dead_module_issue ~loc ~moduleName =
+let make_dead_module_issue ~loc ~moduleName : Issue.t =
   {
-    name = "Warning Dead Module";
+    Issue.name = "Warning Dead Module";
     severity = Warning;
     loc;
     description =

analysis/reanalyze/src/AnalysisResult.mli

@@ -3,21 +3,19 @@
     The solver returns this instead of logging directly.
     All side effects (logging, JSON output) happen in the reporting phase. *)
 
-open Common
-
 type t
 (** Immutable analysis result *)
 
 val empty : t
 (** Empty result with no issues *)
 
-val add_issue : t -> issue -> t
+val add_issue : t -> Issue.t -> t
 (** Add a single issue to the result *)
 
-val add_issues : t -> issue list -> t
+val add_issues : t -> Issue.t list -> t
 (** Add multiple issues to the result *)
 
-val get_issues : t -> issue list
+val get_issues : t -> Issue.t list
 (** Get all issues in order they were added *)
 
 val issue_count : t -> int
@@ -27,11 +25,11 @@ val issue_count : t -> int
 
 val make_dead_issue :
   loc:Location.t ->
-  deadWarning:deadWarning ->
+  deadWarning:Issue.deadWarning ->
   path:string ->
   message:string ->
-  issue
+  Issue.t
 (** Create a dead code warning issue *)
 
-val make_dead_module_issue : loc:Location.t -> moduleName:Name.t -> issue
+val make_dead_module_issue : loc:Location.t -> moduleName:Name.t -> Issue.t
 (** Create a dead module warning issue *)

analysis/reanalyze/src/Cli.ml

@@ -0,0 +1,20 @@
+(** Command-line interface options for reanalyze.
+    These refs are set by argument parsing in Reanalyze.ml *)
+
+let debug = ref false
+let ci = ref false
+
+(** The command was a -cmt variant (e.g. -exception-cmt) *)
+let cmtCommand = ref false
+
+let experimental = ref false
+let json = ref false
+
+(* names to be considered live values *)
+let liveNames = ref ([] : string list)
+
+(* paths of files where all values are considered live *)
+let livePaths = ref ([] : string list)
+
+(* paths of files to exclude from analysis *)
+let excludePaths = ref ([] : string list)

analysis/reanalyze/src/Common.ml

@@ -3,22 +3,9 @@
     These are references that span file boundaries and need to be resolved
     after all files are processed. *)
 
-open Common
-
-(* Position-keyed hashtable *)
-module PosHash = Hashtbl.Make (struct
-  type t = Lexing.position
-
-  let hash x =
-    let s = Filename.basename x.Lexing.pos_fname in
-    Hashtbl.hash (x.Lexing.pos_cnum, s)
-
-  let equal (x : t) y = x = y
-end)
-
 (** {2 Item types} *)
 
-type exception_ref = {exception_path: Path.t; loc_from: Location.t}
+type exception_ref = {exception_path: DcePath.t; loc_from: Location.t}
 
 type optional_arg_call = {
   pos_to: Lexing.position;

analysis/reanalyze/src/CrossFileItems.ml

@@ -18,7 +18,7 @@ type builder
 val create_builder : unit -> builder
 
 val add_exception_ref :
-  builder -> exception_path:Common.Path.t -> loc_from:Location.t -> unit
+  builder -> exception_path:DcePath.t -> loc_from:Location.t -> unit
 (** Add a cross-file exception reference (defined in another file). *)
 
 val add_optional_arg_call :
@@ -44,14 +44,14 @@ val process_exception_refs :
   t ->
   refs:References.builder ->
   file_deps:FileDeps.builder ->
-  find_exception:(Common.Path.t -> Location.t option) ->
+  find_exception:(DcePath.t -> Location.t option) ->
   config:DceConfig.t ->
   unit
 (** Process cross-file exception references. *)
 
 (** {2 Optional Args State} *)
 
 val compute_optional_args_state :
-  t -> decls:Declarations.t -> Common.OptionalArgsState.t
+  t -> decls:Declarations.t -> OptionalArgsState.t
 (** Compute final optional args state from calls and function references.
     Pure function - does not mutate declarations. *)