Move traversals, static exits and path translation out of Lambda

lambda.ml defined the representation and then a good deal that merely used it.
The distinction that matters is whether a function needs to construct terms
without going through the constructors: the constructors and the folds they
run do, and nothing else does. Everything in the second category can live
outside, and saying so in the module structure makes the rule checkable rather
than a convention.

Lambda_traverse takes the generic walks - shallow_exists, shallow_map_sharing,
iter, free_variables, subst_lambda - and make_key, which the preceding commit
made expressible through the constructors.

Lambda_exits takes the static exit mechanism: the counters, make_exit,
as_simple_exit, make_catch_delayed. An exit number and the catch a handler is
wrapped in are a protocol over the representation, not part of it.

Transl_path takes transl_normal_path and its three callers. This is
translation, and it was the only reason lambda.ml depended on Env and Path.

Moving the last two out made the type private to them, which found two places
building raw because they could rather than because they had to: make_exit's
Lstaticraise and transl_normal_path's Lconst, Lglobal_module, Lvar and Lprim.
Both now go through the constructors, which for these is the same term.

Five helpers that only the folds use - eq_primitive_approx, eq_comparison,
const_eq_approx, cmp_int32, cmp_float - stop being exported.

lambda.ml goes from 1495 lines to 1200. Generated JavaScript is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01W8g8qwBARAcvW9MyuKQq8H

Author: cristianoc

CHANGELOG.md

@@ -71,6 +71,7 @@
 
 - Normalize Lambda terms where they are built: a match guard stays structured data until its fallthrough is known, and `apply` and `mk_builtin` go through the folding constructors. https://github.com/rescript-lang/rescript/pull/8615
 - Replace non-escaping local mutable blocks with scalar bindings when all uses are direct field accesses, generalizing reference unboxing to multi-field records and references captured by JavaScript closures. https://github.com/rescript-lang/rescript/pull/8617
+- Split `lambda.ml` into the IR and its traversals, static exits and path translation, so the module defining `Lambda.t` no longer reaches into `Env` or `Path`. https://github.com/rescript-lang/rescript/pull/8618
 - Merge the duplicate Lam intermediate representation into Lambda, removing the conversion layer and obsolete supporting infrastructure. Lambda is now a single private, normalized representation, with generated JavaScript remaining semantically unchanged. https://github.com/rescript-lang/rescript/pull/8608
 - Add genType and source map controls and output to the developer playground. https://github.com/rescript-lang/rescript/pull/8448
 - Rework the object-type representation end to end: object rows are plain field chains carrying a per-field mutability state (no phantom setter members), object literals are typed directly and property access and assignment are first-class AST and Lambda nodes shared between the Lambda and JS pipelines, and dead class-system remnants (the field-presence lattice, the class-abbreviation memo on object types, method-send typing) are removed. https://github.com/rescript-lang/rescript/pull/8597

compiler/core/lam_compile.ml

@@ -1283,7 +1283,7 @@ let compile output_prefix =
       (lambda_cxt : Lam_compile_context.t) =
     let new_cxt = {lambda_cxt with continuation = NeedValue Not_tail} in
     let emitted_id =
-      if Set_ident.mem (Lambda.free_variables body) id then id
+      if Set_ident.mem (Lambda_traverse.free_variables body) id then id
       else Ext_ident.create_tmp ~name:"_for_of" ()
     in
     let block =
@@ -1306,7 +1306,7 @@ let compile output_prefix =
       (body : Lambda.t) (lambda_cxt : Lam_compile_context.t) =
     let new_cxt = {lambda_cxt with continuation = NeedValue Not_tail} in
     let emitted_id =
-      if Set_ident.mem (Lambda.free_variables body) id then id
+      if Set_ident.mem (Lambda_traverse.free_variables body) id then id
       else Ext_ident.create_tmp ~name:"_for_await_of" ()
     in
     let block =

compiler/core/lam_compile_main.ml

@@ -255,7 +255,7 @@ let required_modules (lam : Lambda.t) : Lam_module_ident.Hash_set.t =
     | Lglobal_module id ->
       Lam_module_ident.Hash_set.add required (Lam_module_ident.of_ml id)
     | _ -> ());
-    Lambda.iter collect lam
+    Lambda_traverse.iter collect lam
   in
   collect lam;
   required

compiler/core/lam_dce.ml

@@ -46,22 +46,23 @@ let remove export_idents (rest : Lam_group.t list) : Lam_group.t list =
     Ext_list.fold_left rest export_idents (fun acc x ->
         match x with
         | Single (kind, id, lam) -> (
-          Hash_ident.add ident_free_vars id (Lambda.free_variables lam);
+          Hash_ident.add ident_free_vars id (Lambda_traverse.free_variables lam);
           match kind with
           | Alias | StrictOpt -> acc
           | Strict | Variable -> id :: acc)
         | Recursive bindings ->
           Ext_list.fold_left bindings acc (fun acc (id, lam) ->
-              Hash_ident.add ident_free_vars id (Lambda.free_variables lam);
+              Hash_ident.add ident_free_vars id
+                (Lambda_traverse.free_variables lam);
               match lam with
               | Lfunction _ -> acc
               | _ -> id :: acc)
         | Nop lam ->
           if Lam_analysis.no_side_effects lam then acc
           else
             (* its free varaibles here will be defined above *)
-            Set_ident.fold (Lambda.free_variables lam) acc (fun x acc ->
-                x :: acc))
+            Set_ident.fold (Lambda_traverse.free_variables lam) acc
+              (fun x acc -> x :: acc))
   in
   let visited = transitive_closure initial_idents ident_free_vars in
   Ext_list.fold_left rest [] (fun acc x ->

compiler/core/lam_exit_code.ml

@@ -28,12 +28,12 @@ let has_exit_code lam exits =
     | Lfunction _ -> false
     (* static exit can not cross function boundary *)
     | Lstaticraise (p, _) when exits p -> true
-    | _ -> Lambda.shallow_exists aux lam
+    | _ -> Lambda_traverse.shallow_exists aux lam
   in
   aux lam
 
 let rec has_exit (lam : Lambda.t) =
   match lam with
   | Lfunction _ -> false
   | Lstaticraise (_, _) -> true
-  | _ -> Lambda.shallow_exists has_exit lam
+  | _ -> Lambda_traverse.shallow_exists has_exit lam

compiler/core/lam_pass_exits.ml

@@ -197,7 +197,7 @@ let subst_helper (subst : subst_tbl) (query : int -> int) (lam : Lambda.t) :
           Ext_list.fold_right2 xs ys Ident.empty (fun x y t ->
               Ident.add x (Lambda.var y) t)
         in
-        Ext_list.fold_right2 ys ls (Lambda.subst_lambda env handler)
+        Ext_list.fold_right2 ys ls (Lambda_traverse.subst_lambda env handler)
           (fun y l r -> Lambda.let_ Strict y l r)
       | None -> Lambda.staticraise i ls)
     | Lvar _ | Lconst _ -> lam

compiler/core/lam_pass_guard_raises.ml

@@ -3,9 +3,9 @@ let rec guard_raises (lam : Lambda.t) : Lambda.t =
   | Lifthenelse (a, (Lprim {primitive = Praise} as b), c) -> (
     match c with
     (* A constant alternative is already as flat as it gets. *)
-    | Lconst _ -> Lambda.shallow_map_sharing guard_raises lam
+    | Lconst _ -> Lambda_traverse.shallow_map_sharing guard_raises lam
     | _ ->
       Lambda.seq
         (Lambda.if_ (guard_raises a) b Lambda.lambda_unit)
         (guard_raises c))
-  | _ -> Lambda.shallow_map_sharing guard_raises lam
+  | _ -> Lambda_traverse.shallow_map_sharing guard_raises lam

compiler/core/lam_pass_sroa.ml

@@ -47,7 +47,9 @@ let rec analyze block uses (lam : Lambda.t) =
     else false
   | _ ->
     not
-      (Lambda.shallow_exists (fun child -> not (analyze block uses child)) lam)
+      (Lambda_traverse.shallow_exists
+         (fun child -> not (analyze block uses child))
+         lam)
 
 let discard_value value body =
   if Lam_analysis.no_side_effects value then body else Lambda.seq value body
@@ -68,7 +70,7 @@ let rec rewrite block fields uses (lam : Lambda.t) =
      loudly instead of silently losing the write. *)
   | Lvar id when Ident.same id block -> assert false
   | Lassign (id, _) when Ident.same id block -> assert false
-  | _ -> Lambda.shallow_map_sharing (rewrite block fields uses) lam
+  | _ -> Lambda_traverse.shallow_map_sharing (rewrite block fields uses) lam
 
 let fields_for_block block info field_count =
   let fallback () =
@@ -141,4 +143,4 @@ let rec simplify (lam : Lambda.t) =
     | _ ->
       if init' == init && body' == body then lam
       else Lambda.let_ kind block init' body')
-  | _ -> Lambda.shallow_map_sharing simplify lam
+  | _ -> Lambda_traverse.shallow_map_sharing simplify lam

compiler/core/polyvar_pattern_match.ml

@@ -45,7 +45,7 @@ let convert (xs : input) : output =
   let os : value list ref = ref [] in
   xs
   |> List.iteri (fun i (hash, (name, act)) ->
-      match Lambda.make_key act with
+      match Lambda_traverse.make_key act with
       | None -> os := {stamp = i; hash_names_act = ([(hash, name)], act)} :: !os
       | Some key ->
         Coll.add_or_update coll key