Experiment: Reactive analysis with skip-lite CMT cache

Vendor skip-lite library and integrate reactive analysis capabilities:

- Vendor skip-lite marshal_cache and reactive_file_collection modules
- Modify C++ code to handle ReScript CMT file format (CMI+CMT headers)
- Add CmtCache module for mmap-based CMT file reading
- Add ReactiveAnalysis module for incremental file processing
- Add CLI flags: -cmt-cache, -reactive, -runs
- Add README.md with usage and benchmark instructions

Benchmark results (~5000 files):
- Standard: CMT processing 0.78s, Total 1.01s
- Reactive (warm): CMT processing 0.01s, Total 0.20s
- Speedup: 74x for CMT processing, 5x total

The reactive mode caches processed file_data and uses read_cmt_if_changed
to skip unchanged files entirely on subsequent runs.

Author: cristianoc

analysis/reanalyze/README.md

@@ -0,0 +1,169 @@
+# Reanalyze
+
+Dead code analysis and other experimental analyses for ReScript.
+
+## Analyses
+
+- **Dead Code Elimination (DCE)** - Detect unused values, types, and modules
+- **Exception Analysis** - Track potential exceptions through call chains
+- **Termination Analysis** - Experimental analysis for detecting non-terminating functions
+
+## Usage
+
+```bash
+# Run DCE analysis on current project (reads rescript.json)
+rescript-editor-analysis reanalyze -config
+
+# Run DCE analysis on specific CMT directory
+rescript-editor-analysis reanalyze -dce-cmt path/to/lib/bs
+
+# Run all analyses
+rescript-editor-analysis reanalyze -all
+```
+
+## Performance Options
+
+### Parallel Processing
+
+Use multiple CPU cores for faster analysis:
+
+```bash
+# Use 4 parallel domains
+reanalyze -config -parallel 4
+
+# Auto-detect number of cores
+reanalyze -config -parallel -1
+```
+
+### CMT Cache (Experimental)
+
+Use memory-mapped cache for CMT file reading:
+
+```bash
+reanalyze -config -cmt-cache
+```
+
+### Reactive Mode (Experimental)
+
+Cache processed file data and skip unchanged files on subsequent runs:
+
+```bash
+reanalyze -config -reactive
+```
+
+This provides significant speedup for repeated analysis (e.g., in a watch mode or service):
+
+| Mode | CMT Processing | Total | Speedup |
+|------|----------------|-------|---------|
+| Standard | 0.78s | 1.01s | 1x |
+| Reactive (warm) | 0.01s | 0.20s | 5x |
+
+### Benchmarking
+
+Run analysis multiple times to measure cache effectiveness:
+
+```bash
+reanalyze -config -reactive -timing -runs 3
+```
+
+## CLI Flags
+
+| Flag | Description |
+|------|-------------|
+| `-config` | Read analysis mode from rescript.json |
+| `-dce` | Run dead code analysis |
+| `-exception` | Run exception analysis |
+| `-termination` | Run termination analysis |
+| `-all` | Run all analyses |
+| `-parallel n` | Use n parallel domains (0=sequential, -1=auto) |
+| `-cmt-cache` | Use mmap cache for CMT files |
+| `-reactive` | Cache processed file_data, skip unchanged files |
+| `-runs n` | Run analysis n times (for benchmarking) |
+| `-timing` | Report timing of analysis phases |
+| `-debug` | Print debug information |
+| `-json` | Output in JSON format |
+| `-ci` | Internal flag for CI mode |
+
+## Architecture
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for details on the analysis pipeline.
+
+The DCE analysis is structured as a pure pipeline:
+
+1. **MAP** - Process each `.cmt` file independently → per-file data
+2. **MERGE** - Combine all per-file data → project-wide view
+3. **SOLVE** - Compute dead/live status → issues
+4. **REPORT** - Output issues
+
+This design enables order-independence, parallelization, and incremental updates.
+
+## Reactive Analysis
+
+The reactive mode (`-reactive`) uses skip-lite's Marshal_cache to efficiently detect file changes:
+
+1. **First run**: All files are processed and results cached
+2. **Subsequent runs**: Only changed files are re-processed
+3. **Unchanged files**: Return cached `file_data` immediately (no I/O or unmarshalling)
+
+This is the foundation for a persistent analysis service that can respond to file changes in milliseconds.
+
+## Development
+
+### Testing
+
+```bash
+# Run reanalyze tests
+make test-reanalyze
+
+# Run with shuffled file order (order-independence test)
+make test-reanalyze-order-independence
+
+# Run parallel mode test
+make test-reanalyze-parallel
+```
+
+### Benchmarking
+
+The benchmark project generates ~5000 files to measure analysis performance:
+
+```bash
+cd tests/analysis_tests/tests-reanalyze/deadcode-benchmark
+
+# Generate files, build, and run sequential vs parallel benchmark
+make benchmark
+
+# Compare CMT cache effectiveness (cold vs warm)
+make time-cache
+
+# Benchmark reactive mode (shows speedup on repeated runs)
+make time-reactive
+```
+
+#### Reactive Benchmark
+
+The `make time-reactive` target runs:
+
+1. **Standard mode** (baseline) - Full analysis every time
+2. **Reactive mode** with 3 runs - First run is cold (processes all files), subsequent runs are warm (skip unchanged files)
+
+Example output:
+
+```
+=== Reactive mode benchmark ===
+
+Standard (baseline):
+  CMT processing: 0.78s
+  Total: 1.01s
+
+Reactive mode (3 runs):
+  === Run 1/3 ===
+  CMT processing: 0.78s
+  Total: 1.02s
+  === Run 2/3 ===
+  CMT processing: 0.01s  <-- 74x faster
+  Total: 0.20s           <-- 5x faster
+  === Run 3/3 ===
+  CMT processing: 0.01s
+  Total: 0.20s
+```
+

analysis/reanalyze/src/Cli.ml

@@ -27,3 +27,12 @@ let parallel = ref 0
 
 (* timing: report internal timing of analysis phases *)
 let timing = ref false
+
+(* use mmap cache for CMT files *)
+let cmtCache = ref false
+
+(* use reactive/incremental analysis (caches processed file_data) *)
+let reactive = ref false
+
+(* number of analysis runs (for benchmarking reactive mode) *)
+let runs = ref 1

analysis/reanalyze/src/CmtCache.ml

@@ -0,0 +1,42 @@
+(** CMT file cache using Marshal_cache for efficient mmap-based reading.
+    
+    This module provides cached reading of CMT files with automatic
+    invalidation when files change on disk. It's used to speed up
+    repeated analysis runs by avoiding re-reading unchanged files. *)
+
+[@@@alert "-unsafe"]
+
+(** Read a CMT file, using the mmap cache for efficiency.
+    The file is memory-mapped and the cache automatically detects
+    when the file changes on disk. *)
+let read_cmt path : Cmt_format.cmt_infos =
+  Marshal_cache.with_unmarshalled_file path Fun.id
+
+(** Read a CMT file only if it changed since the last access.
+    Returns [Some cmt_infos] if the file changed (or first access),
+    [None] if the file is unchanged.
+    
+    This is the key function for incremental analysis - unchanged
+    files return [None] immediately without any unmarshalling. *)
+let read_cmt_if_changed path : Cmt_format.cmt_infos option =
+  Marshal_cache.with_unmarshalled_if_changed path Fun.id
+
+(** Clear the CMT cache, unmapping all memory.
+    Useful for testing or to free memory. *)
+let clear () = Marshal_cache.clear ()
+
+(** Invalidate a specific path in the cache.
+    The next read will re-load the file from disk. *)
+let invalidate path = Marshal_cache.invalidate path
+
+(** Cache statistics *)
+type stats = {
+  entry_count: int;
+  mapped_bytes: int;
+}
+
+(** Get cache statistics *)
+let stats () : stats =
+  let s = Marshal_cache.stats () in
+  { entry_count = s.entry_count; mapped_bytes = s.mapped_bytes }
+

analysis/reanalyze/src/CmtCache.mli

@@ -0,0 +1,28 @@
+(** CMT file cache using Marshal_cache for efficient mmap-based reading.
+    
+    This module provides cached reading of CMT files with automatic
+    invalidation when files change on disk. *)
+
+val read_cmt : string -> Cmt_format.cmt_infos
+(** Read a CMT file, using the mmap cache for efficiency. *)
+
+val read_cmt_if_changed : string -> Cmt_format.cmt_infos option
+(** Read a CMT file only if it changed since the last access.
+    Returns [Some cmt_infos] if the file changed (or first access),
+    [None] if the file is unchanged. *)
+
+val clear : unit -> unit
+(** Clear the CMT cache, unmapping all memory. *)
+
+val invalidate : string -> unit
+(** Invalidate a specific path in the cache. *)
+
+type stats = {
+  entry_count: int;
+  mapped_bytes: int;
+}
+(** Cache statistics *)
+
+val stats : unit -> stats
+(** Get cache statistics *)
+