From 0fce1b4c7feb6c7614f30c8202a84fb36d0f3c04 Mon Sep 17 00:00:00 2001
From: Cristiano Calcagno <cristianoc@users.noreply.github.com>
Date: Mon, 17 Aug 2026 09:53:23 +0200
Subject: [PATCH] Eliminate Pjs_fn_make, Pjs_fn_make_unit, and
 unsafe_adjust_to_arity

With structural arity, "function of arity n" is a construction
invariant rather than a goal state: translcore builds every Lfunction
with exactly the parameters its type declares. The arity-enforcement
layer therefore disappears:

- Function literals are emitted directly; the Pjs_fn_make wrapper that
  every function passed through was resolved as a no-op by
  lam_pass_alpha_conversion, but only *after* deep_flatten,
  simplify_exits and simplify_alias had run with the function hidden
  inside an Lprim, acting as an accidental optimization barrier.
- Pjs_fn_make_unit was a one-bit metadata channel: its entire effect
  was setting one_unit_arg so js_exp_make drops the unit parameter.
  translcore now sets the attribute directly, gated on the parameter
  pattern binding no identifiers (a () or _ pattern) - a more
  principled test than the alpha pass's check that the parameter was
  named "param".
- The active-pattern currying split in transl_function is deleted. It
  preserved pattern-effect timing across curried application steps,
  which no longer exist: total applications supply all arguments at
  once and explicit partial application eta-defers the entire call.
  The old output proves the point - the split's closures were
  immediately applied by the arity adapter, so only the allocations
  are gone (see mutable_uncurry_test).
- The I<N> unboxed-record producer (the @this method-callback
  encoding) is removed: the general Record_unboxed translation already
  returns the single field unboxed, and the wrapped value is a literal
  of matching arity.

With no producers left, both primitive constructors and every consumer
arm are deleted, including the 230-line unsafe_adjust_to_arity (its
only callers were the two Pjs_fn_make resolution sites).

On recursive modules: removing the wrapper lets the static
recursive-module compilation path see module members that are plain
functions, replacing the Primitive_module.init/update bootstrap with
hoisted function declarations. This is safe because the static path's
own applicability check now sees the functions it was designed to
check - the wrapper was hiding them, pessimizing compilation - and the
bootstrap demonstrably remains for members that are not plain
functions (rec_module_test keeps its lazy/value cases dynamic).

Verified: stdlib byte-identical; full test suite green; JS output
changes limited to removed adapter closures, removed no-op module
bootstraps, better name preservation, and constant propagation.

Keep beta-residue let chains (immutable blocks and aliases feeding a
final apply) local in Lam_pass_deep_flatten instead of hoisting them
into the enclosing group: with the wrapper gone, beta reduction happens
before flatten2, and hoisting the argument bindings to toplevel put
them beyond Lam_pass_lets_dce's reach (a_recursive_type kept a named
intermediate that master inlined; the snapshot pins the restored form).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Cristiano Calcagno <cristianoc@users.noreply.github.com>
---
 CHANGELOG.md                                  |   1 +
 compiler/core/design.md                       |  15 --
 compiler/core/lam.ml                          |   7 -
 compiler/core/lam_analysis.ml                 |   3 +-
 compiler/core/lam_compile.ml                  |   6 -
 compiler/core/lam_compile_primitive.ml        |   3 +-
 compiler/core/lam_convert.ml                  |   2 -
 compiler/core/lam_eta_conversion.ml           | 230 ------------------
 compiler/core/lam_eta_conversion.mli          |   3 -
 compiler/core/lam_pass_alpha_conversion.ml    |  19 --
 compiler/core/lam_pass_deep_flatten.ml        |  20 ++
 compiler/core/lam_primitive.ml                |  10 +-
 compiler/core/lam_primitive.mli               |   2 -
 compiler/core/lam_print.ml                    |   2 -
 compiler/ml/lambda.ml                         |   2 -
 compiler/ml/lambda.mli                        |   2 -
 compiler/ml/printlambda.ml                    |   2 -
 compiler/ml/translattribute.ml                |   4 +-
 compiler/ml/translcore.ml                     |  73 ++----
 tests/belt_tests/src/rec_module_opt.mjs       |  73 +-----
 .../tests/src/DisambiguateOptionalFields.mjs  |   4 +-
 tests/tests/src/UncurriedAlways.mjs           |  28 +--
 tests/tests/src/ari_regress_test.mjs          |   8 +-
 tests/tests/src/ast_abstract_test.mjs         |   8 +-
 tests/tests/src/async_inline.mjs              |   8 +-
 tests/tests/src/attr_test.mjs                 |   4 +-
 tests/tests/src/dollar_escape_test.mjs        |  12 +-
 tests/tests/src/flexible_array_test.mjs       |  12 +-
 tests/tests/src/int_poly_var.mjs              |   4 +-
 tests/tests/src/module_parameter_test.mjs     |   2 +-
 tests/tests/src/mutable_uncurry_test.mjs      |  92 +++----
 tests/tests/src/pipe_syntax.mjs               |   8 +-
 tests/tests/src/ppx_apply_test.mjs            |  17 +-
 tests/tests/src/pr6726.mjs                    |   4 +-
 tests/tests/src/rec_module_test.mjs           | 127 ++--------
 tests/tests/src/recursive_module_test.mjs     |  22 +-
 tests/tests/src/submodule.mjs                 |   4 +-
 tests/tests/src/test_ari.mjs                  |   4 +-
 tests/tests/src/test_demo.mjs                 |   7 +-
 tests/tests/src/test_google_closure.mjs       |  13 +-
 tests/tests/src/uncurried_pipe.mjs            |  32 +--
 .../src/expected/TestPpx.res.jsout            |   8 +-
 42 files changed, 187 insertions(+), 720 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69409487802..3e77acfd55a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -48,6 +48,7 @@
 
 - Sync the platform npm package's compiler binaries (`packages/@rescript/<platform>/bin`) via dune promotion on every `dune build`, instead of Makefile/CI copy steps that only ran when make did: a plain `dune build` can no longer leave `cli/*.js` and the test harnesses running a stale compiler. https://github.com/rescript-lang/rescript/pull/8560
 - Remove unused compiler IR definitions, modules, helpers, error variants, and Typedtree fields. https://github.com/rescript-lang/rescript/pull/8551 https://github.com/rescript-lang/rescript/pull/8555
+- Eliminate the `Pjs_fn_make`/`Pjs_fn_make_unit` arity-adjustment primitives and the `unsafe_adjust_to_arity` machinery: with structural arity, functions are constructed at their final arity, so the enforcement layer (and the active-pattern currying split it compensated for) is deleted. Generated code improves: no adapter closures for patterns on mutable fields, better constant propagation and name preservation, and recursive modules whose members are plain functions compile statically without the runtime bootstrap. https://github.com/rescript-lang/rescript/pull/8570
 - Cleanups enabled by structural arity: remove the unreachable `Too_many_arguments` error and the `?in_function` threading through the type checker that existed only to decorate it; remove the dead `function$`-vs-arrow unification bridge, `Ctype.arity`, and the unused parsetree arity helpers; deduplicate the analysis arrow-flattening helpers. https://github.com/rescript-lang/rescript/pull/8569
 
 - Make the typed layers n-ary as well: `Types.Tarrow` carries a parameter list, `Texp_function` carries typed parameters (label, ident, pattern, per-parameter exhaustiveness) and a body, and `Ttyp_arrow`/`Otyp_arrow` follow. The `arity` annotation and its `int option` phantom state are gone from the compiler entirely; `push_defaults` in translcore and the hand-rolled gather-until-arity walks in gentype, reanalyze, and the outcome printer are deleted. The cmi and cmt magic numbers are bumped (`Caml1999I023`/`Caml1999T023`). Generated JavaScript is byte-identical across the test suite (optional-parameter internals are named `*opt_<label>*` instead of `*opt*`, visible only in the rare unprettified case); reanalyze no longer emits spurious empty optional-argument references, and genType recovers real parameter names after defaulted parameters. https://github.com/rescript-lang/rescript/pull/8568
diff --git a/compiler/core/design.md b/compiler/core/design.md
index a0c0b46d051..6b319d18227 100644
--- a/compiler/core/design.md
+++ b/compiler/core/design.md
@@ -173,20 +173,6 @@ We can simply do inlining, it may have side efffect in `b0`, `b1`, our optimizer
 
 Maybe in the future, we should lift the restriction about `variadic` (delegate to `slow` mode when we can not resolve it statically, my personal expereince is that people will complain about why it fails to compile more than why it is slow in some corner cases)
 
-Note this also interacts with `[@uncurry]`
-
-for example
-
-```ocaml
-external filter : 'a array -> ('a -> bool [@uncurry]) -> 'a array = "filter"
-[@@send]
-
-let f xs =
-    xs |. filter (fun x -> x > 2)
-```
-
-Here whether the callback gets inlined to the call of `filter` will have an effect on how `Pjs_fn_make` gets cancelled.
-
 Note when we pattern match over the original lamba,`Levent` needs to be removed as early as possible. Due to the existence of `Levent`, we can not pattern match over nested original raw lambda.
 
 We turned off event generation temporarily
@@ -474,4 +460,3 @@ we do the optimizer, e.g, `Js_exp_make.int_comp`, we need make sure the peepwhol
 
 
 
-
diff --git a/compiler/core/lam.ml b/compiler/core/lam.ml
index 019d2334587..a3c1e9d06c1 100644
--- a/compiler/core/lam.ml
+++ b/compiler/core/lam.ml
@@ -140,13 +140,6 @@ let rec is_eta_conversion_exn params inner_args outer_args : t list =
   match (params, inner_args, outer_args) with
   | x :: xs, Lvar y :: ys, r :: rest when Ident.same x y ->
     r :: is_eta_conversion_exn xs ys rest
-  | ( x :: xs,
-      Lprim
-        ({primitive = Pjs_fn_make _ | Pjs_fn_make_unit; args = [Lvar y]} as p)
-      :: ys,
-      r :: rest )
-    when Ident.same x y ->
-    Lprim {p with args = [r]} :: is_eta_conversion_exn xs ys rest
   | [], [], [] -> []
   | _, _, _ -> raise_notrace Not_simple_form
 
diff --git a/compiler/core/lam_analysis.ml b/compiler/core/lam_analysis.ml
index 54dac1787b8..d8cd3095328 100644
--- a/compiler/core/lam_analysis.ml
+++ b/compiler/core/lam_analysis.ml
@@ -46,8 +46,7 @@ let rec no_side_effects (lam : Lam.t) : bool =
       | _ -> false)
     | Pcreate_extension _ | Ptypeof | Pis_null | Pis_not_none | Psome
     | Psome_not_nest | Pis_undefined | Pis_null_undefined | Pnull_to_opt
-    | Pnull_undefined_to_opt | Pjs_fn_make _ | Pjs_fn_make_unit
-    | Pjs_object_create _ | Pimport
+    | Pnull_undefined_to_opt | Pjs_object_create _ | Pimport
     (* TODO: check *)
     | Pmakeblock _
     (* whether it's mutable or not *)
diff --git a/compiler/core/lam_compile.ml b/compiler/core/lam_compile.ml
index ad7e08c0024..dfb703f37d5 100644
--- a/compiler/core/lam_compile.ml
+++ b/compiler/core/lam_compile.ml
@@ -1828,12 +1828,6 @@ let compile output_prefix =
                       }
                       body))))
       | _ -> assert false)
-    | {primitive = Pjs_fn_make arity; args = [fn]; loc} ->
-      compile_lambda lambda_cxt
-        (Lam_eta_conversion.unsafe_adjust_to_arity loc ~to_:arity ?from:None fn)
-    | {primitive = Pjs_fn_make_unit; args = [fn]; loc} ->
-      compile_lambda lambda_cxt fn
-    | {primitive = Pjs_fn_make _; args = [] | _ :: _ :: _} -> assert false
     | {primitive = Pjs_object_create labels; args} ->
       let args_block, args_expr =
         if args = [] then ([], [])
diff --git a/compiler/core/lam_compile_primitive.ml b/compiler/core/lam_compile_primitive.ml
index 47b41b17896..17ef67d9527 100644
--- a/compiler/core/lam_compile_primitive.ml
+++ b/compiler/core/lam_compile_primitive.ml
@@ -155,8 +155,7 @@ let translate output_prefix loc (cxt : Lam_compile_context.t)
   | Pis_undefined -> E.is_undef (Ext_list.singleton_exn args)
   | Pis_null_undefined -> E.is_null_undefined (Ext_list.singleton_exn args)
   | Ptypeof -> E.typeof (Ext_list.singleton_exn args)
-  | Pjs_unsafe_downgrade _ | Pdebugger | Pjs_fn_make _ | Pjs_fn_make_unit
-  | Pjs_fn_method ->
+  | Pjs_unsafe_downgrade _ | Pdebugger | Pjs_fn_method ->
     assert false (* already handled by {!Lam_compile} *)
   | Pstringadd -> (
     match args with
diff --git a/compiler/core/lam_convert.ml b/compiler/core/lam_convert.ml
index 49027c85654..fe248d849e6 100644
--- a/compiler/core/lam_convert.ml
+++ b/compiler/core/lam_convert.ml
@@ -315,8 +315,6 @@ let lam_prim ~primitive:(p : Lambda.primitive) ~args loc : Lam.t =
   | Pis_poly_var_block -> prim ~primitive:Pis_poly_var_block ~args loc
   | Pjs_raw_expr -> assert false
   | Pjs_raw_stmt -> assert false
-  | Pjs_fn_make arity -> prim ~primitive:(Pjs_fn_make arity) ~args loc
-  | Pjs_fn_make_unit -> prim ~primitive:Pjs_fn_make_unit ~args loc
   | Pjs_fn_method -> prim ~primitive:Pjs_fn_method ~args loc
 
 (* Does not exist since we compile array in js backend unlike native backend *)
diff --git a/compiler/core/lam_eta_conversion.ml b/compiler/core/lam_eta_conversion.ml
index 320ecd41647..058af703b82 100644
--- a/compiler/core/lam_eta_conversion.ml
+++ b/compiler/core/lam_eta_conversion.ml
@@ -73,233 +73,3 @@ let transform_under_supply n ap_info fn args =
     Ext_list.fold_left bindings rest (fun lam (id, x) ->
         Lam.let_ Strict id x lam)
   | _, _ -> assert false
-
-(* Invariant: mk0 : (unit -> 'a0) -> 'a0 t
-                TODO: this case should be optimized,
-                we need check where we handle [arity=0]
-                as a special case --
-                if we do an optimization before compiling
-                into lambda
-
-   {[Fn.mk0]} is not intended for use by normal users
-
-   so we assume [Fn.mk0] is only used in such cases
-   {[
-     Fn.mk0 (fun _ -> .. )
-   ]}
-   when it is passed as a function directly
-*)
-(*TODO: can be optimized ?
-  {[\ x y -> (\u -> body x) x y]}
-  {[\u x -> body x]}
-    rewrite rules
-  {[
-    \x -> body
-          --
-          \y (\x -> body ) y
-  ]}
-  {[\ x y -> (\a b c -> g a b c) x y]}
-  {[ \a b -> \c -> g a b c ]}
-*)
-
-(** Unsafe function, we are changing arity here, it should be applied 
-    cautiously, since 
-    [let u = f] and we are chaning the arity of [f] it will affect 
-    the collection of [u]
-    A typical use case is to pass an OCaml function to JS side as a callback (i.e, [@uncurry])
-*)
-let unsafe_adjust_to_arity loc ~(to_ : int) ?(from : int option) (fn : Lam.t) :
-    Lam.t =
-  let ap_info : Lam.ap_info =
-    {ap_loc = loc; ap_inlined = Default_inline; ap_status = App_na}
-  in
-  let is_async_fn =
-    match fn with
-    | Lfunction {attr = {async}} -> async
-    | _ -> false
-  in
-  match (from, fn) with
-  | Some from, _ | None, Lfunction {arity = from} -> (
-    if from = to_ || is_async_fn then fn
-    else if to_ = 0 then
-      match fn with
-      | Lfunction {params = [param]; body; loc} ->
-        Lam.function_ ~loc ~arity:0 ~attr:Lambda.default_function_attribute
-          ~params:[]
-          ~body:(Lam.let_ Alias param Lam.unit body)
-        (* could be only introduced by
-           {[ Pjs_fn_make 0 ]} <-
-           {[ fun [@bs] () -> .. ]}
-        *)
-      | _ -> (
-        let wrapper, new_fn =
-          match fn with
-          | Lvar _
-          | Lprim
-              {
-                primitive = Pfield (_, Fld_module _);
-                args = [(Lglobal_module _ | Lvar _)];
-                _;
-              } ->
-            (None, fn)
-          | _ ->
-            let partial_arg = Ext_ident.create Literals.partial_arg in
-            (Some partial_arg, Lam.var partial_arg)
-        in
-
-        let cont =
-          Lam.function_ ~loc ~attr:Lambda.default_function_attribute ~arity:0
-            ~params:[]
-            ~body:(Lam.apply new_fn [Lam.unit] ap_info)
-        in
-
-        match wrapper with
-        | None -> cont
-        | Some partial_arg -> Lam.let_ Strict partial_arg fn cont)
-    else if to_ > from then
-      match fn with
-      | Lfunction {params; body; loc} ->
-        (* {[fun x -> f]} ->
-           {[ fun x y -> f y ]}
-        *)
-        let extra_args =
-          Ext_list.init (to_ - from) (fun _ -> Ident.create Literals.param)
-        in
-        let rec mk_apply body vars =
-          match vars with
-          | [] -> body
-          | var :: vars -> mk_apply (Lam.apply body [var] ap_info) vars
-        in
-        Lam.function_ ~loc ~attr:Lambda.default_function_attribute ~arity:to_
-          ~params:(Ext_list.append params extra_args)
-          ~body:(mk_apply body (Ext_list.map extra_args Lam.var))
-      | _ -> (
-        let arity = to_ in
-        let extra_args =
-          Ext_list.init to_ (fun _ -> Ident.create Literals.param)
-        in
-        let wrapper, new_fn =
-          match fn with
-          | Lvar _
-          | Lprim
-              {
-                primitive = Pfield (_, Fld_module _);
-                args = [(Lglobal_module _ | Lvar _)];
-                _;
-              } ->
-            (None, fn)
-          | _ ->
-            let partial_arg = Ext_ident.create Literals.partial_arg in
-            (Some partial_arg, Lam.var partial_arg)
-        in
-        let cont =
-          Lam.function_ ~loc ~arity ~attr:Lambda.default_function_attribute
-            ~params:extra_args
-            ~body:
-              (let first_args, rest_args = Ext_list.split_at extra_args from in
-               Lam.apply
-                 (Lam.apply new_fn
-                    (Ext_list.map first_args Lam.var)
-                    {ap_info with ap_status = App_infer_full})
-                 (Ext_list.map rest_args Lam.var)
-                 ap_info)
-        in
-        match wrapper with
-        | None -> cont
-        | Some partial_arg -> Lam.let_ Strict partial_arg fn cont)
-    else
-      (* add3  --adjust to arity 1 ->
-         fun x -> (fun y z -> add3 x y z )
-
-         [fun x y z -> f x y z ]
-         [fun x -> [fun y z -> f x y z ]]
-         This is okay if the function is not held by other..
-      *)
-      match fn with
-      | Lfunction {params; body; loc}
-      (* TODO check arity = List.length params in debug mode *) ->
-        let arity = to_ in
-        let extra_outer_args, extra_inner_args =
-          Ext_list.split_at params arity
-        in
-        Lam.function_ ~loc ~arity ~attr:Lambda.default_function_attribute
-          ~params:extra_outer_args
-          ~body:
-            (Lam.function_ ~loc ~arity:(from - to_)
-               ~attr:Lambda.default_function_attribute ~params:extra_inner_args
-               ~body)
-      | _ -> (
-        let extra_outer_args =
-          Ext_list.init to_ (fun _ -> Ident.create Literals.param)
-        in
-        let wrapper, new_fn =
-          match fn with
-          | Lvar _
-          | Lprim
-              {
-                primitive = Pfield (_, Fld_module _);
-                args = [(Lglobal_module _ | Lvar _)];
-                _;
-              } ->
-            (None, fn)
-          | _ ->
-            let partial_arg = Ext_ident.create Literals.partial_arg in
-            (Some partial_arg, Lam.var partial_arg)
-        in
-        let cont =
-          Lam.function_ ~loc ~arity:to_ ~params:extra_outer_args
-            ~attr:Lambda.default_function_attribute
-            ~body:
-              (let arity = from - to_ in
-               let extra_inner_args =
-                 Ext_list.init arity (fun _ -> Ident.create Literals.param)
-               in
-               Lam.function_ ~loc ~arity ~params:extra_inner_args
-                 ~attr:Lambda.default_function_attribute
-                 ~body:
-                   (Lam.apply new_fn
-                      (Ext_list.map_append extra_outer_args
-                         (Ext_list.map extra_inner_args Lam.var)
-                         Lam.var)
-                      {ap_info with ap_status = App_infer_full}))
-        in
-        match wrapper with
-        | None -> cont
-        | Some partial_arg -> Lam.let_ Strict partial_arg fn cont))
-  | None, _ ->
-    (* In this case [fn] is not [Lfunction], otherwise we would get [arity] *)
-    if to_ = 0 then
-      let wrapper, new_fn =
-        match fn with
-        | Lvar _
-        | Lprim
-            {
-              primitive = Pfield (_, Fld_module _);
-              args = [(Lglobal_module _ | Lvar _)];
-              _;
-            } ->
-          (None, fn)
-        | _ ->
-          let partial_arg = Ext_ident.create Literals.partial_arg in
-          (Some partial_arg, Lam.var partial_arg)
-      in
-
-      let cont =
-        Lam.function_ ~loc ~attr:Lambda.default_function_attribute ~arity:0
-          ~params:[]
-          ~body:(Lam.apply new_fn [Lam.unit] ap_info)
-      in
-
-      match wrapper with
-      | None -> cont
-      | Some partial_arg -> Lam.let_ Strict partial_arg fn cont
-    else transform_under_supply to_ ap_info fn []
-
-(* | _ ->
-   let partial_arg = Ext_ident.create Literals.partial_arg in
-   Lam.let_ Strict partial_arg fn
-    (let arity = to_ in
-     let extra_args = Ext_list.init arity (fun _ -> Ident.create Literals.param) in
-     Lam.function_ ~arity ~kind:Curried ~params:extra_args
-       ~body:(Lam.apply fn (Ext_list.map Lam.var extra_args ) loc Lam.App_na )
-    ) *)
diff --git a/compiler/core/lam_eta_conversion.mli b/compiler/core/lam_eta_conversion.mli
index 2b8da1e78ac..9696587e2c6 100644
--- a/compiler/core/lam_eta_conversion.mli
+++ b/compiler/core/lam_eta_conversion.mli
@@ -29,6 +29,3 @@
 *)
 
 val transform_under_supply : int -> Lam.ap_info -> Lam.t -> Lam.t list -> Lam.t
-
-val unsafe_adjust_to_arity :
-  Location.t -> to_:int -> ?from:int -> Lam.t -> Lam.t
diff --git a/compiler/core/lam_pass_alpha_conversion.ml b/compiler/core/lam_pass_alpha_conversion.ml
index 8ab29e4ca75..e8ec2a51b12 100644
--- a/compiler/core/lam_pass_alpha_conversion.ml
+++ b/compiler/core/lam_pass_alpha_conversion.ml
@@ -64,25 +64,6 @@ let alpha_conversion (meta : Lam_stats.t) (lam : Lam.t) : Lam.t =
       let bindings = Ext_list.map_snd bindings simpl in
       Lam.letrec bindings (simpl body)
     | Lglobal_module _ -> lam
-    | Lprim {primitive = Pjs_fn_make len as primitive; args = [arg]; loc} -> (
-      match
-        Lam_arity.get_first_arity (Lam_arity_analysis.get_arity meta arg)
-      with
-      | Some x ->
-        let arg = simpl arg in
-        Lam_eta_conversion.unsafe_adjust_to_arity loc ~to_:len ~from:x arg
-      | None -> Lam.prim ~primitive ~args:[simpl arg] loc)
-    | Lprim {primitive = Pjs_fn_make_unit; args = [arg]; loc} ->
-      let arg =
-        match arg with
-        | Lfunction {arity = 1; params = [x]; attr; body; loc}
-          when Ident.name x = "param" (* "()" *) ->
-          Lam.function_ ~loc ~params:[x]
-            ~attr:{attr with one_unit_arg = true}
-            ~body ~arity:1
-        | _ -> arg
-      in
-      simpl arg
     | Lprim {primitive; args; loc} ->
       Lam.prim ~primitive ~args:(Ext_list.map args simpl) loc
     | Lfunction {arity; params; body; attr; loc} ->
diff --git a/compiler/core/lam_pass_deep_flatten.ml b/compiler/core/lam_pass_deep_flatten.ml
index 33ceff7cd07..db4de083e93 100644
--- a/compiler/core/lam_pass_deep_flatten.ml
+++ b/compiler/core/lam_pass_deep_flatten.ml
@@ -114,6 +114,19 @@ let lambda_of_groups ~(rev_bindings : Lam_group.t list) (result : Lam.t) : Lam.t
     since its semantics depend on whether v is used or not
     return value are in reverse order, but handled by [lambda_of_groups]
 *)
+(* The shape [let x = <immutable block> in ... in apply f args]: the residue
+   left by beta reduction of an immediately applied function. *)
+let rec rhs_is_beta_residue (lam : Lam.t) =
+  match lam with
+  | Llet
+      ( (Alias | Strict | StrictOpt),
+        _,
+        (Lprim {primitive = Pmakeblock (_, _, Immutable)} | Lvar _),
+        rest ) ->
+    rhs_is_beta_residue rest
+  | Lapply _ -> true
+  | _ -> false
+
 let deep_flatten (lam : Lam.t) : Lam.t =
   let rec flatten (acc : Lam_group.t list) (lam : Lam.t) :
       Lam.t * Lam_group.t list =
@@ -145,6 +158,13 @@ let deep_flatten (lam : Lam.t) : Lam.t =
                  ~args:[Lam.var new_id]
                  Location.none (* FIXME*))
               body))
+    | Llet (str, id, arg, body) when rhs_is_beta_residue arg ->
+      (* A let chain of immutable blocks and aliases feeding a final apply is
+         the residue of beta reducing an immediately applied function. Keep
+         it local: hoisting the bindings into the enclosing group would put
+         them beyond [Lam_pass_lets_dce]'s reach, which substitutes
+         single-use arguments back into the call. *)
+      flatten (Single (str, id, aux arg) :: acc) body
     | Llet (str, id, arg, body) -> (
       (*
                          {[ let match = (a,b,c)
diff --git a/compiler/core/lam_primitive.ml b/compiler/core/lam_primitive.ml
index 18467698ad6..a1ea361b259 100644
--- a/compiler/core/lam_primitive.ml
+++ b/compiler/core/lam_primitive.ml
@@ -157,8 +157,6 @@ type t =
   | Pinit_mod
   | Pupdate_mod
   | Praw_js_code of Js_raw_info.t
-  | Pjs_fn_make of int
-  | Pjs_fn_make_unit
   (* we wrap it when do the conversion to prevent
      accendential optimization
      play safe first
@@ -230,8 +228,8 @@ let eq_primitive_approx (lhs : t) (rhs : t) =
   | Psome_not_nest | Pis_undefined | Pis_null_undefined | Pimport | Ptypeof
   | Pfn_arity | Pis_poly_var_block | Pdebugger | Pinit_mod | Pupdate_mod
   | Pduprecord | Pmakearray | Parraylength | Parrayrefu | Parraysetu
-  | Parrayrefs | Parraysets | Pjs_fn_make_unit | Pjs_fn_method | Phash
-  | Phash_mixstring | Phash_mixint | Phash_finalmix | Precord_rest _ ->
+  | Parrayrefs | Parraysets | Pjs_fn_method | Phash | Phash_mixstring
+  | Phash_mixint | Phash_finalmix | Precord_rest _ ->
     rhs = lhs
   (* Reachable only via the optimizer's term-equality comparison, which the
      test suite doesn't exercise for tagged templates. *)
@@ -300,9 +298,5 @@ let eq_primitive_approx (lhs : t) (rhs : t) =
     match rhs with
     | Pjs_unsafe_downgrade rhs -> name = rhs.name && setter = rhs.setter
     | _ -> false)
-  | Pjs_fn_make i -> (
-    match rhs with
-    | Pjs_fn_make i1 -> i = i1
-    | _ -> false)
   | Praw_js_code _ -> false
 (* TOO lazy, here comparison is only approximation*)
diff --git a/compiler/core/lam_primitive.mli b/compiler/core/lam_primitive.mli
index 561c9e31255..238045e9f4c 100644
--- a/compiler/core/lam_primitive.mli
+++ b/compiler/core/lam_primitive.mli
@@ -151,8 +151,6 @@ type t =
   | Pinit_mod
   | Pupdate_mod
   | Praw_js_code of Js_raw_info.t
-  | Pjs_fn_make of int
-  | Pjs_fn_make_unit
   | Pjs_fn_method
   | Pnull_to_opt
   | Pnull_undefined_to_opt
diff --git a/compiler/core/lam_print.ml b/compiler/core/lam_print.ml
index 3c9122fba00..dd692e8842a 100644
--- a/compiler/core/lam_print.ml
+++ b/compiler/core/lam_print.ml
@@ -56,8 +56,6 @@ let primitive ppf (prim : Lam_primitive.t) =
   | Pjs_unsafe_downgrade {name; setter} ->
     if setter then fprintf ppf "##%s#=" name else fprintf ppf "##%s" name
   | Pfn_arity -> fprintf ppf "fn.length"
-  | Pjs_fn_make i -> fprintf ppf "js_fn_make_%i" i
-  | Pjs_fn_make_unit -> fprintf ppf "js_fn_make_unit"
   | Pjs_fn_method -> fprintf ppf "js_fn_method"
   | Pdebugger -> fprintf ppf "debugger"
   | Praw_js_code _ -> fprintf ppf "[raw]"
diff --git a/compiler/ml/lambda.ml b/compiler/ml/lambda.ml
index 8dd296b2707..987d844ddd6 100644
--- a/compiler/ml/lambda.ml
+++ b/compiler/ml/lambda.ml
@@ -300,8 +300,6 @@ type primitive =
   | Pis_poly_var_block
   | Pjs_raw_expr
   | Pjs_raw_stmt
-  | Pjs_fn_make of int
-  | Pjs_fn_make_unit
   | Pjs_fn_method
   (* Tagged template literal: [tag; strings_array; values_array] *)
   | Ptagged_template
diff --git a/compiler/ml/lambda.mli b/compiler/ml/lambda.mli
index 3a4ae0f9049..efe4d9802b5 100644
--- a/compiler/ml/lambda.mli
+++ b/compiler/ml/lambda.mli
@@ -273,8 +273,6 @@ type primitive =
   | Pis_poly_var_block
   | Pjs_raw_expr
   | Pjs_raw_stmt
-  | Pjs_fn_make of int
-  | Pjs_fn_make_unit
   | Pjs_fn_method
   | Ptagged_template
 
diff --git a/compiler/ml/printlambda.ml b/compiler/ml/printlambda.ml
index 681f33a98ba..adbe108c1b2 100644
--- a/compiler/ml/printlambda.ml
+++ b/compiler/ml/printlambda.ml
@@ -260,8 +260,6 @@ let primitive ppf = function
   | Pis_poly_var_block -> fprintf ppf "#is_poly_var_block"
   | Pjs_raw_expr -> fprintf ppf "#raw_expr"
   | Pjs_raw_stmt -> fprintf ppf "#raw_stmt"
-  | Pjs_fn_make arity -> fprintf ppf "#fn_mk(%d)" arity
-  | Pjs_fn_make_unit -> fprintf ppf "#fn_mk_unit"
   | Pjs_fn_method -> fprintf ppf "#fn_method"
   (* Debug-only dump, exercised solely under -drawlambda/-dlambda. *)
   | Ptagged_template -> fprintf ppf "#tagged_template" [@coverage off]
diff --git a/compiler/ml/translattribute.ml b/compiler/ml/translattribute.ml
index 11043f688a5..7c9c9a7a0a0 100644
--- a/compiler/ml/translattribute.ml
+++ b/compiler/ml/translattribute.ml
@@ -66,7 +66,7 @@ let get_inline_attribute l =
   let attr, _ = find_attribute is_inline_attribute l in
   parse_inline_attribute attr
 
-let rec add_inline_attribute (expr : Lambda.lambda) loc attributes =
+let add_inline_attribute (expr : Lambda.lambda) loc attributes =
   match (expr, get_inline_attribute attributes) with
   | expr, Default_inline -> expr
   | Lfunction ({attr} as funct), inline ->
@@ -76,8 +76,6 @@ let rec add_inline_attribute (expr : Lambda.lambda) loc attributes =
       Location.prerr_warning loc (Warnings.Duplicated_attribute "inline"));
     let attr = {attr with inline} in
     Lfunction {funct with attr}
-  | Lprim (((Pjs_fn_make _ | Pjs_fn_make_unit) as p), [e], l), _ ->
-    Lambda.Lprim (p, [add_inline_attribute e loc attributes], l)
   | expr, Always_inline ->
     Location.prerr_warning loc (Warnings.Misplaced_attribute "inline");
     expr
diff --git a/compiler/ml/translcore.ml b/compiler/ml/translcore.ml
index 3e6be9bc248..6a55f5d0264 100644
--- a/compiler/ml/translcore.ml
+++ b/compiler/ml/translcore.ml
@@ -618,8 +618,16 @@ and transl_exp0 (e : Typedtree.expression) : Lambda.lambda =
       | None -> None
       | Some (directive, _) -> Some directive
     in
-    let arity = List.length fparams in
     let params, lbody, return_unit = transl_function e.exp_loc fparams body in
+    let one_unit_arg =
+      match (fparams, (Ctype.expand_head e.exp_env e.exp_type).desc) with
+      | [{fp_pat}], Tarrow ([{lbl = Nolabel; typ}], _)
+        when Typedtree.pat_bound_idents fp_pat = [] -> (
+        match (Ctype.expand_head e.exp_env typ).desc with
+        | Tconstr (Pident {name = "unit"}, [], _) -> true
+        | _ -> false)
+      | _ -> false
+    in
     let attr =
       {
         default_function_attribute with
@@ -627,23 +635,11 @@ and transl_exp0 (e : Typedtree.expression) : Lambda.lambda =
         async;
         return_unit;
         directive;
+        one_unit_arg;
       }
     in
     let loc = e.exp_loc in
-    let lambda = Lfunction {params; body = lbody; attr; loc} in
-    let prim =
-      let expanded = Ctype.expand_head e.exp_env e.exp_type in
-      match (Btype.repr expanded).desc with
-      | Tarrow ({lbl = Nolabel; typ} :: _, _) -> (
-        match (Ctype.expand_head e.exp_env typ).desc with
-        | Tconstr (Pident {name = "unit"}, [], _) -> Pjs_fn_make_unit
-        | _ -> Pjs_fn_make arity)
-      | _ -> Pjs_fn_make arity
-    in
-    Lprim
-      ( prim (* could be replaced with Opaque in the future except arity 0*),
-        [lambda],
-        loc )
+    Lfunction {params; body = lbody; attr; loc}
   | Texp_apply {funct; args = oargs}
     when List.exists
            (fun (attr, _) -> attr.txt = "res.taggedTemplate")
@@ -1016,33 +1012,12 @@ and transl_function loc (params : function_param list) body =
         fp_partial,
       is_base_type body.exp_env body.exp_type Predef.path_unit )
   | {fp_param; fp_pat; fp_partial} :: rest ->
-    if Parmatch.inactive ~partial:fp_partial fp_pat then
-      let lparams, lbody, return_unit = transl_function loc rest body in
-      ( fp_param :: lparams,
-        Matching.for_function loc None (Lvar fp_param)
-          [(fp_pat, lbody)]
-          fp_partial,
-        return_unit )
-    else
-      (* An "active" pattern (whose compilation can have side effects, e.g.
-         a lazy or string pattern) must run when its own parameter group is
-         applied: split the remaining parameters into a nested curried
-         function, as the legacy chain representation did. *)
-      let lparams, lbody, _ = transl_function loc rest body in
-      let inner =
-        Lfunction
-          {
-            params = lparams;
-            body = lbody;
-            attr = default_function_attribute;
-            loc;
-          }
-      in
-      ( [fp_param],
-        Matching.for_function loc None (Lvar fp_param)
-          [(fp_pat, inner)]
-          fp_partial,
-        false )
+    let lparams, lbody, return_unit = transl_function loc rest body in
+    ( fp_param :: lparams,
+      Matching.for_function loc None (Lvar fp_param)
+        [(fp_pat, lbody)]
+        fp_partial,
+      return_unit )
 
 and transl_let rec_flag pat_expr_list body =
   match rec_flag with
@@ -1080,20 +1055,6 @@ and transl_let rec_flag pat_expr_list body =
 
 and transl_record loc env fields repres opt_init_expr =
   match (opt_init_expr, repres, fields) with
-  | None, Record_unboxed _, [|({lbl_name; lbl_loc}, Overridden (_, expr), _)|]
-    ->
-    (* ReScript uncurried encoding *)
-    let loc = lbl_loc in
-    let lambda = transl_exp expr in
-    if lbl_name.[0] = 'I' then
-      let arity_s = String.sub lbl_name 1 (String.length lbl_name - 1) in
-      let arity = Int32.of_string arity_s |> Int32.to_int in
-      Lprim
-        ( Pjs_fn_make arity,
-          (* could be replaced with Opaque in the future except arity 0*)
-          [lambda],
-          loc )
-    else lambda
   | _ -> (
     let size = Array.length fields in
     let optional =
diff --git a/tests/belt_tests/src/rec_module_opt.mjs b/tests/belt_tests/src/rec_module_opt.mjs
index 34577f8c6b0..65f54fb4e3c 100644
--- a/tests/belt_tests/src/rec_module_opt.mjs
+++ b/tests/belt_tests/src/rec_module_opt.mjs
@@ -1,23 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Belt_Id from "@rescript/belt/lib/es6/src/Belt_Id.mjs";
-import * as Primitive_module from "@rescript/runtime/lib/es6/Primitive_module.mjs";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.mjs";
 
-let A = Primitive_module.init([
-  "rec_module_opt.res",
-  13,
-  4
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "cmp"
-    ]]
-});
-
-let AComparable = Belt_Id.MakeComparable(A);
-
 function cmp(t1, t2) {
   if (t1.TAG === "Leaf") {
     if (t2.TAG === "Leaf") {
@@ -32,71 +17,31 @@ function cmp(t1, t2) {
   }
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "cmp"
-    ]]
-}, A, {
+let A = {
   cmp: cmp
-});
+};
+
+let AComparable = Belt_Id.MakeComparable(A);
 
 let X0 = {};
 
 let Y0 = {};
 
-let X1 = Primitive_module.init([
-  "rec_module_opt.res",
-  42,
-  19
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "f"
-    ]]
-});
-
-let Y1 = Primitive_module.init([
-  "rec_module_opt.res",
-  45,
-  12
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "f"
-    ]]
-});
-
 function f(x) {
   return x + 1 | 0;
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "f"
-    ]]
-}, X1, {
+let X1 = {
   f: f
-});
+};
 
 function f$1(x) {
   return x + 2 | 0;
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "f"
-    ]]
-}, Y1, {
+let Y1 = {
   f: f$1
-});
+};
 
 let X;
 
@@ -109,4 +54,4 @@ export {
   X1,
   Y1,
 }
-/* A Not a pure module */
+/* AComparable Not a pure module */
diff --git a/tests/tests/src/DisambiguateOptionalFields.mjs b/tests/tests/src/DisambiguateOptionalFields.mjs
index ac27a889db9..51a529dd30d 100644
--- a/tests/tests/src/DisambiguateOptionalFields.mjs
+++ b/tests/tests/src/DisambiguateOptionalFields.mjs
@@ -9,13 +9,13 @@ function f2(v) {
   return v.x;
 }
 
-let res = 3;
-
 let v = {
   x: 3,
   y: 4
 };
 
+let res = 3;
+
 export {
   f1,
   f2,
diff --git a/tests/tests/src/UncurriedAlways.mjs b/tests/tests/src/UncurriedAlways.mjs
index ca174051882..6b701e35e78 100644
--- a/tests/tests/src/UncurriedAlways.mjs
+++ b/tests/tests/src/UncurriedAlways.mjs
@@ -5,19 +5,11 @@ function foo(x, y) {
   return x + y | 0;
 }
 
-let z = 7;
-
 function bar(x, y) {
   return x + y | 0;
 }
 
-let b = 7;
-
-let w = 7;
-
-let a = 7;
-
-console.log(a);
+console.log(7);
 
 [1].map(x => x + 1 | 0);
 
@@ -168,7 +160,7 @@ function fn1(a, b, param) {
   return a() + b | 0;
 }
 
-function a$1(__x) {
+function a(__x) {
   return 3;
 }
 
@@ -221,10 +213,10 @@ function f(a, b, c) {
 
 function f2(a, b, c, d, e) {
   let __tuple_internal_obj = a(b);
-  let param_0 = c(__tuple_internal_obj, d);
-  let param_1 = d(__tuple_internal_obj, 1, 2);
-  let param_2 = e(__tuple_internal_obj);
-  return (param_0 + param_1 | 0) + param_2 | 0;
+  let u = c(__tuple_internal_obj, d);
+  let v = d(__tuple_internal_obj, 1, 2);
+  let h = e(__tuple_internal_obj);
+  return (u + v | 0) + h | 0;
 }
 
 function f3$1(foo, x) {
@@ -242,6 +234,12 @@ let Pipe = {
   f4: f4
 };
 
+let z = 7;
+
+let b = 7;
+
+let w = 7;
+
 export {
   foo,
   z,
@@ -261,7 +259,7 @@ export {
   OptMixed,
   fn,
   fn1,
-  a$1 as a,
+  a,
   PartialApplication,
   ReverseApplication,
   Pipe,
diff --git a/tests/tests/src/ari_regress_test.mjs b/tests/tests/src/ari_regress_test.mjs
index 4bc6c918bca..15fe3c580fc 100644
--- a/tests/tests/src/ari_regress_test.mjs
+++ b/tests/tests/src/ari_regress_test.mjs
@@ -3,8 +3,6 @@
 import * as Mocha from "mocha";
 import * as Test_utils from "./test_utils.mjs";
 
-let g = 7;
-
 let h = {
   contents: 0
 };
@@ -15,16 +13,14 @@ function g1(x, y) {
   return (xx, yy) => (xx + yy | 0) + u | 0;
 }
 
-let u = 8;
-
-let x = u + 6 | 0;
+let x = 14;
 
 function v(__x) {
   return g1(3, 4)(6, __x);
 }
 
 Mocha.describe("Ari_regress_test", () => {
-  Mocha.test("curry", () => Test_utils.eq("File \"ari_regress_test.res\", line 25, characters 7-14", g, 7));
+  Mocha.test("curry", () => Test_utils.eq("File \"ari_regress_test.res\", line 25, characters 7-14", 7, 7));
   Mocha.test("curry2", () => Test_utils.eq("File \"ari_regress_test.res\", line 30, characters 6-13", 14, (v(1), v(1))));
   Mocha.test("curry3", () => Test_utils.eq("File \"ari_regress_test.res\", line 40, characters 7-14", x, 14));
   Mocha.test("ref count", () => Test_utils.eq("File \"ari_regress_test.res\", line 44, characters 7-14", h.contents, 2));
diff --git a/tests/tests/src/ast_abstract_test.mjs b/tests/tests/src/ast_abstract_test.mjs
index 5bb18b893bc..8c43e67f24a 100644
--- a/tests/tests/src/ast_abstract_test.mjs
+++ b/tests/tests/src/ast_abstract_test.mjs
@@ -46,16 +46,16 @@ function idx(v) {
   Test_utils.eq("File \"ast_abstract_test.res\", line 21, characters 18-25", xFromJs(v), v);
 }
 
-let x0 = "a";
-
-let x1 = "b";
-
 Mocha.describe("Ast_abstract_test", () => {
   Mocha.test("jsConverter roundtrip for #a", () => idx("a"));
   Mocha.test("jsConverter roundtrip for #b", () => idx("b"));
   Mocha.test("jsConverter roundtrip for #c", () => idx("c"));
 });
 
+let x0 = "a";
+
+let x1 = "b";
+
 export {
   tToJs,
   tFromJs,
diff --git a/tests/tests/src/async_inline.mjs b/tests/tests/src/async_inline.mjs
index e5d8b12954d..bf094dafb11 100644
--- a/tests/tests/src/async_inline.mjs
+++ b/tests/tests/src/async_inline.mjs
@@ -54,12 +54,8 @@ async function uncurriedIdAsync(x) {
   return x;
 }
 
-let tci = 3;
-
 let tcia = curriedIdAsync(3);
 
-let tui = 3;
-
 let tuia = uncurriedIdAsync(3);
 
 function nested1() {
@@ -74,6 +70,10 @@ function onSubmit() {
   return React.useCallback(async b => await b);
 }
 
+let tci = 3;
+
+let tui = 3;
+
 export {
   willBeInlined,
   inlined,
diff --git a/tests/tests/src/attr_test.mjs b/tests/tests/src/attr_test.mjs
index d839ca7232a..ead63203f0b 100644
--- a/tests/tests/src/attr_test.mjs
+++ b/tests/tests/src/attr_test.mjs
@@ -5,8 +5,6 @@ function u(x, y) {
   return x + y | 0;
 }
 
-let h = 3;
-
 function max2(x, y) {
   return x + y;
 }
@@ -19,6 +17,8 @@ function f(x) {
   });
 }
 
+let h = 3;
+
 export {
   u,
   h,
diff --git a/tests/tests/src/dollar_escape_test.mjs b/tests/tests/src/dollar_escape_test.mjs
index 987895a6e7c..ec3bcdbe91b 100644
--- a/tests/tests/src/dollar_escape_test.mjs
+++ b/tests/tests/src/dollar_escape_test.mjs
@@ -7,21 +7,21 @@ function $$(x, y) {
   return x + y | 0;
 }
 
-let v = 3;
-
 function $$$plus(x, y) {
   return x * y | 0;
 }
 
-let u = 3;
-
 Mocha.describe("Dollar_escape_test", () => {
   Mocha.test("dollar escape operators", () => {
-    Test_utils.eq("File \"dollar_escape_test.res\", line 14, characters 7-14", v, 3);
-    Test_utils.eq("File \"dollar_escape_test.res\", line 15, characters 7-14", u, 3);
+    Test_utils.eq("File \"dollar_escape_test.res\", line 14, characters 7-14", 3, 3);
+    Test_utils.eq("File \"dollar_escape_test.res\", line 15, characters 7-14", 3, 3);
   });
 });
 
+let v = 3;
+
+let u = 3;
+
 export {
   $$,
   v,
diff --git a/tests/tests/src/flexible_array_test.mjs b/tests/tests/src/flexible_array_test.mjs
index 10c14996b35..5f346368a24 100644
--- a/tests/tests/src/flexible_array_test.mjs
+++ b/tests/tests/src/flexible_array_test.mjs
@@ -288,14 +288,16 @@ let u = of_array([
   6
 ]);
 
-if (!$eq$tilde(sort(u), [
+let x = sort(u);
+
+if (!Primitive_object.equal(x, of_array([
     1,
     2,
     2,
     3,
     5,
     6
-  ])) {
+  ]))) {
   throw {
     RE_EXN_ID: "Assert_failure",
     _1: [
@@ -309,7 +311,11 @@ if (!$eq$tilde(sort(u), [
 
 let v = Stdlib_Array.fromInitializer(500, i => 500 - i | 0);
 
-$eq$tilde(sort(of_array(v)), Stdlib_Array.fromInitializer(500, i => i + 1 | 0));
+let x$1 = sort(of_array(v));
+
+let y = Stdlib_Array.fromInitializer(500, i => i + 1 | 0);
+
+Primitive_object.equal(x$1, of_array(y));
 
 export {
   sub,
diff --git a/tests/tests/src/int_poly_var.mjs b/tests/tests/src/int_poly_var.mjs
index 0df33e30b3f..46de8352006 100644
--- a/tests/tests/src/int_poly_var.mjs
+++ b/tests/tests/src/int_poly_var.mjs
@@ -58,8 +58,6 @@ function h(x) {
   return x === 0;
 }
 
-let g = /* 'b' */98;
-
 let hihi = f3(3, 0);
 
 let hh10 = "3" === 3;
@@ -166,6 +164,8 @@ Mocha.describe("Int_poly_var", () => {
 
 let u = 1;
 
+let g = /* 'b' */98;
+
 let hh9 = true;
 
 let begin = 3;
diff --git a/tests/tests/src/module_parameter_test.mjs b/tests/tests/src/module_parameter_test.mjs
index 87464a30df7..f189982ffbe 100644
--- a/tests/tests/src/module_parameter_test.mjs
+++ b/tests/tests/src/module_parameter_test.mjs
@@ -22,7 +22,7 @@ function v(x) {
 
 Mocha.describe("Module_parameter_test", () => {
   Mocha.test("const", () => Test_utils.eq("File \"module_parameter_test.res\", line 24, characters 7-14", 1, v0));
-  Mocha.test("other", () => Test_utils.eq("File \"module_parameter_test.res\", line 28, characters 7-14", 3, v("abc")));
+  Mocha.test("other", () => Test_utils.eq("File \"module_parameter_test.res\", line 28, characters 7-14", 3, "abc".length));
 });
 
 export {
diff --git a/tests/tests/src/mutable_uncurry_test.mjs b/tests/tests/src/mutable_uncurry_test.mjs
index be465216199..ec8122f7eaf 100644
--- a/tests/tests/src/mutable_uncurry_test.mjs
+++ b/tests/tests/src/mutable_uncurry_test.mjs
@@ -34,77 +34,57 @@ function t3(param, param$1, param$2) {
 function ut4(param, param$1, param$2, param$3) {
   let x0 = param.contents;
   let x1 = param$1.contents;
-  return (param => {
-    let x2 = param.contents;
-    return param => {
-      let x3 = param.contents;
-      return [
-        x0,
-        x1,
-        x2,
-        x3
-      ];
-    };
-  })(param$2)(param$3);
+  let x2 = param$2.contents;
+  let x3 = param$3.contents;
+  return [
+    x0,
+    x1,
+    x2,
+    x3
+  ];
 }
 
 function t4(param, param$1, param$2, param$3) {
   let x0 = param.contents;
   let x1 = param$1.contents;
-  return (param => {
-    let x2 = param.contents;
-    return param => {
-      let x3 = param.contents;
-      return [
-        x0,
-        x1,
-        x2,
-        x3
-      ];
-    };
-  })(param$2)(param$3);
+  let x2 = param$2.contents;
+  let x3 = param$3.contents;
+  return [
+    x0,
+    x1,
+    x2,
+    x3
+  ];
 }
 
 function ut5(param, param$1, param$2, param$3, param$4) {
   let x0 = param.contents;
   let x1 = param$1.contents;
-  return (param => {
-    let x2 = param.contents;
-    return param => {
-      let x3 = param.contents;
-      return param => {
-        let x4 = param.contents;
-        return [
-          x0,
-          x1,
-          x2,
-          x3,
-          x4
-        ];
-      };
-    };
-  })(param$2)(param$3)(param$4);
+  let x2 = param$2.contents;
+  let x3 = param$3.contents;
+  let x4 = param$4.contents;
+  return [
+    x0,
+    x1,
+    x2,
+    x3,
+    x4
+  ];
 }
 
 function t5(param, param$1, param$2, param$3, param$4) {
   let x0 = param.contents;
   let x1 = param$1.contents;
-  return (param => {
-    let x2 = param.contents;
-    return param => {
-      let x3 = param.contents;
-      return param => {
-        let x4 = param.contents;
-        return [
-          x0,
-          x1,
-          x2,
-          x3,
-          x4
-        ];
-      };
-    };
-  })(param$2)(param$3)(param$4);
+  let x2 = param$2.contents;
+  let x3 = param$3.contents;
+  let x4 = param$4.contents;
+  return [
+    x0,
+    x1,
+    x2,
+    x3,
+    x4
+  ];
 }
 
 function nested0(param, param$1, param$2) {
diff --git a/tests/tests/src/pipe_syntax.mjs b/tests/tests/src/pipe_syntax.mjs
index ed1ec40fed8..9606f24960e 100644
--- a/tests/tests/src/pipe_syntax.mjs
+++ b/tests/tests/src/pipe_syntax.mjs
@@ -42,10 +42,10 @@ function f2(a, b, c, d) {
 
 function f3(a, b, c, d, e) {
   let __tuple_internal_obj = a(b);
-  let param_0 = c(__tuple_internal_obj, d);
-  let param_1 = d(__tuple_internal_obj, 1, 2);
-  let param_2 = e(__tuple_internal_obj);
-  return (param_0 + param_1 | 0) + param_2 | 0;
+  let u = c(__tuple_internal_obj, d);
+  let v = d(__tuple_internal_obj, 1, 2);
+  let h = e(__tuple_internal_obj);
+  return (u + v | 0) + h | 0;
 }
 
 function f4(a, b, c) {
diff --git a/tests/tests/src/ppx_apply_test.mjs b/tests/tests/src/ppx_apply_test.mjs
index 7448a293511..b5aa2e665a5 100644
--- a/tests/tests/src/ppx_apply_test.mjs
+++ b/tests/tests/src/ppx_apply_test.mjs
@@ -3,8 +3,6 @@
 import * as Mocha from "mocha";
 import * as Test_utils from "./test_utils.mjs";
 
-let u = 3;
-
 function nullary() {
   return 3;
 }
@@ -13,27 +11,26 @@ function unary(a) {
   return a + 3 | 0;
 }
 
-let xx = 6;
-
-Mocha.test("ppx_apply_test_unary", () => Test_utils.eq("File \"ppx_apply_test.res\", line 12, characters 5-12", u, 3));
+Mocha.test("ppx_apply_test_unary", () => Test_utils.eq("File \"ppx_apply_test.res\", line 12, characters 5-12", 3, 3));
 
 function h(a) {
   return xx(a);
 }
 
 Mocha.describe("Ppx_apply_test", () => {
-  Mocha.test("function_application_test", () => {
-    let u = 3;
-    Test_utils.eq("File \"ppx_apply_test.res\", line 25, characters 7-14", u, 3);
-  });
+  Mocha.test("function_application_test", () => Test_utils.eq("File \"ppx_apply_test.res\", line 25, characters 7-14", 3, 3));
   Mocha.test("external_function_test", () => Test_utils.ok("File \"ppx_apply_test.res\", line 30, characters 7-14", true));
 });
 
+let u = 3;
+
+let xx$1 = 6;
+
 export {
   u,
   nullary,
   unary,
-  xx,
+  xx$1 as xx,
   h,
 }
 /*  Not a pure module */
diff --git a/tests/tests/src/pr6726.mjs b/tests/tests/src/pr6726.mjs
index 9f149a2cb04..6add70d5155 100644
--- a/tests/tests/src/pr6726.mjs
+++ b/tests/tests/src/pr6726.mjs
@@ -21,7 +21,7 @@ function test_endian_string(x) {
   return 33;
 }
 
-let v = test_endian_string(1);
+let v = 33;
 
 let Test = {
   test_endian_string: test_endian_string,
@@ -33,4 +33,4 @@ export {
   ExtUnix,
   Test,
 }
-/* v Not a pure module */
+/* No side effect */
diff --git a/tests/tests/src/rec_module_test.mjs b/tests/tests/src/rec_module_test.mjs
index f19b9d0fd89..38f42a7db05 100644
--- a/tests/tests/src/rec_module_test.mjs
+++ b/tests/tests/src/rec_module_test.mjs
@@ -2,31 +2,6 @@
 
 import * as Mocha from "mocha";
 import * as Test_utils from "./test_utils.mjs";
-import * as Primitive_module from "@rescript/runtime/lib/es6/Primitive_module.mjs";
-
-let A = Primitive_module.init([
-  "rec_module_test.res",
-  6,
-  4
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "even"
-    ]]
-});
-
-let B = Primitive_module.init([
-  "rec_module_test.res",
-  18,
-  4
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "odd"
-    ]]
-});
 
 function even(n) {
   if (n === 0) {
@@ -38,15 +13,9 @@ function even(n) {
   }
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "even"
-    ]]
-}, A, {
+let A = {
   even: even
-});
+};
 
 function odd(n) {
   if (n === 1) {
@@ -58,51 +27,9 @@ function odd(n) {
   }
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "odd"
-    ]]
-}, B, {
+let B = {
   odd: odd
-});
-
-let AA = Primitive_module.init([
-  "rec_module_test.res",
-  32,
-  4
-], {
-  TAG: "Module",
-  _0: [
-    [
-      "Function",
-      "even"
-    ],
-    [
-      "Function",
-      "x"
-    ]
-  ]
-});
-
-let BB = Primitive_module.init([
-  "rec_module_test.res",
-  46,
-  4
-], {
-  TAG: "Module",
-  _0: [
-    [
-      "Function",
-      "odd"
-    ],
-    [
-      "Function",
-      "y"
-    ]
-  ]
-});
+};
 
 function even$1(n) {
   if (n === 0) {
@@ -118,22 +45,10 @@ function x() {
   return BB.y() + 3 | 0;
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [
-    [
-      "Function",
-      "even"
-    ],
-    [
-      "Function",
-      "x"
-    ]
-  ]
-}, AA, {
+let AA = {
   even: even$1,
   x: x
-});
+};
 
 function odd$1(n) {
   if (n === 1) {
@@ -141,7 +56,7 @@ function odd$1(n) {
   } else if (n === 0) {
     return false;
   } else {
-    return AA.even(n - 1 | 0);
+    return even$1(n - 1 | 0);
   }
 }
 
@@ -149,22 +64,10 @@ function y() {
   return 32;
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [
-    [
-      "Function",
-      "odd"
-    ],
-    [
-      "Function",
-      "y"
-    ]
-  ]
-}, BB, {
+let BB = {
   odd: odd$1,
   y: y
-});
+};
 
 let Even = {};
 
@@ -178,14 +81,14 @@ Mocha.describe("Rec_module_test", () => {
     false
   ], [
     A.even(2),
-    AA.even(4),
+    even$1(4),
     B.odd(2),
-    BB.odd(4)
+    odd$1(4)
   ]));
-  Mocha.test("test2", () => Test_utils.eq("File \"rec_module_test.res\", line 75, characters 7-14", BB.y(), 32));
-  Mocha.test("test3", () => Test_utils.eq("File \"rec_module_test.res\", line 79, characters 7-14", AA.x(), 35));
+  Mocha.test("test2", () => Test_utils.eq("File \"rec_module_test.res\", line 75, characters 7-14", y(), 32));
+  Mocha.test("test3", () => Test_utils.eq("File \"rec_module_test.res\", line 79, characters 7-14", x(), 35));
   Mocha.test("test4 - A.even", () => Test_utils.eq("File \"rec_module_test.res\", line 83, characters 7-14", true, A.even(2)));
-  Mocha.test("test4 - AA.even", () => Test_utils.eq("File \"rec_module_test.res\", line 87, characters 7-14", true, AA.even(4)));
+  Mocha.test("test4 - AA.even", () => Test_utils.eq("File \"rec_module_test.res\", line 87, characters 7-14", true, even$1(4)));
   Mocha.test("test5", () => Test_utils.eq("File \"rec_module_test.res\", line 91, characters 7-14", false, B.odd(2)));
 });
 
@@ -197,4 +100,4 @@ export {
   Even,
   Odd,
 }
-/* A Not a pure module */
+/*  Not a pure module */
diff --git a/tests/tests/src/recursive_module_test.mjs b/tests/tests/src/recursive_module_test.mjs
index 0fcbc8857b7..b112d87e989 100644
--- a/tests/tests/src/recursive_module_test.mjs
+++ b/tests/tests/src/recursive_module_test.mjs
@@ -24,18 +24,6 @@ Primitive_module.update({
     ]]
 }, Int3, Int3);
 
-let M = Primitive_module.init([
-  "recursive_module_test.res",
-  12,
-  20
-], {
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "fact"
-    ]]
-});
-
 function fact(n) {
   if (n <= 1) {
     return 1;
@@ -44,15 +32,9 @@ function fact(n) {
   }
 }
 
-Primitive_module.update({
-  TAG: "Module",
-  _0: [[
-      "Function",
-      "fact"
-    ]]
-}, M, {
+let M = {
   fact: fact
-});
+};
 
 let fact$1 = M.fact;
 
diff --git a/tests/tests/src/submodule.mjs b/tests/tests/src/submodule.mjs
index 59022e564ce..5e4c70a5fab 100644
--- a/tests/tests/src/submodule.mjs
+++ b/tests/tests/src/submodule.mjs
@@ -55,8 +55,6 @@ let A0 = {
   A1: A1
 };
 
-let v0 = 4;
-
 let v1 = a1(1, 2);
 
 let v2 = a2(1, 2);
@@ -65,6 +63,8 @@ let v3 = a3(1, 2);
 
 let v4 = a4(1, 2);
 
+let v0 = 4;
+
 export {
   A0,
   v0,
diff --git a/tests/tests/src/test_ari.mjs b/tests/tests/src/test_ari.mjs
index 64f2fa23b66..2302a330f5a 100644
--- a/tests/tests/src/test_ari.mjs
+++ b/tests/tests/src/test_ari.mjs
@@ -20,8 +20,6 @@ function f2(extra) {
   return 3 + extra | 0;
 }
 
-let g = 7;
-
 function ff(extra) {
   return U.test_primit(3, extra);
 }
@@ -41,6 +39,8 @@ function length_aux(_len, _x) {
   };
 }
 
+let g = 7;
+
 let length = Stdlib_List.length;
 
 let size = Stdlib_List.size;
diff --git a/tests/tests/src/test_demo.mjs b/tests/tests/src/test_demo.mjs
index 948ecd410a1..b622586bcdb 100644
--- a/tests/tests/src/test_demo.mjs
+++ b/tests/tests/src/test_demo.mjs
@@ -52,13 +52,10 @@ function g1(x, y) {
   return (xx, yy) => (xx + yy | 0) + u | 0;
 }
 
-let u = 8;
-
-let x = u + 6 | 0;
+let x = 14;
 
 function v(extra) {
-  let u = 7;
-  return (6 + extra | 0) + u | 0;
+  return (6 + extra | 0) + 7 | 0;
 }
 
 let nil = "Nil";
diff --git a/tests/tests/src/test_google_closure.mjs b/tests/tests/src/test_google_closure.mjs
index bbe794b0526..89cf2934a95 100644
--- a/tests/tests/src/test_google_closure.mjs
+++ b/tests/tests/src/test_google_closure.mjs
@@ -12,25 +12,20 @@ function f2(a) {
 
 let a = (3).toString();
 
-function f3(extra) {
-  return 101;
-}
-
-let b = f3(2);
-
 let arr = Stdlib_Array.fromInitializer(2, param => 0);
 
 for (let i = 0; i <= 1; ++i) {
-  let f3$1 = extra => i + 1 | 0;
-  arr[i] = f3$1(2);
+  arr[i] = i + 1 | 0;
 }
 
 console.log([
   a,
-  b,
+  101,
   arr
 ]);
 
+let b = 101;
+
 let c = arr;
 
 export {
diff --git a/tests/tests/src/uncurried_pipe.mjs b/tests/tests/src/uncurried_pipe.mjs
index e89588197dd..1e9d407f786 100644
--- a/tests/tests/src/uncurried_pipe.mjs
+++ b/tests/tests/src/uncurried_pipe.mjs
@@ -9,14 +9,6 @@ function addC(x, y) {
   return x + y | 0;
 }
 
-let v7 = 7;
-
-let v17 = 17;
-
-let v27 = 27;
-
-let v37 = 37;
-
 function unary(x) {
   return x + 1 | 0;
 }
@@ -24,29 +16,29 @@ function unary(x) {
 let StandardNotation = {
   add: add,
   addC: addC,
-  v7: v7,
-  v17: v17,
-  v27: v27,
-  v37: v37,
+  v7: 7,
+  v17: 17,
+  v27: 27,
+  v37: 37,
   unary: unary
 };
 
-let v7$1 = 7;
+let v7 = 7;
 
-let v17$1 = 17;
+let v17 = 17;
 
-let v27$1 = 27;
+let v27 = 27;
 
-let v37$1 = 37;
+let v37 = 37;
 
 let v100 = 100;
 
 export {
   StandardNotation,
-  v7$1 as v7,
-  v17$1 as v17,
-  v27$1 as v27,
-  v37$1 as v37,
+  v7,
+  v17,
+  v27,
+  v37,
   v100,
 }
 /* No side effect */
diff --git a/tests/tools_tests/src/expected/TestPpx.res.jsout b/tests/tools_tests/src/expected/TestPpx.res.jsout
index 87ea7737ee8..951349b0e55 100644
--- a/tests/tools_tests/src/expected/TestPpx.res.jsout
+++ b/tests/tools_tests/src/expected/TestPpx.res.jsout
@@ -25,12 +25,10 @@ function two(x, y) {
   return x + y | 0;
 }
 
-let n = 6;
-
 let Arity = {
   one: one,
   two: two,
-  n: n
+  n: 6
 };
 
 React.useState(() => 0);
@@ -63,11 +61,9 @@ function plus(x, y) {
   return x + y | 0;
 }
 
-let z = 3;
-
 let Pipe = {
   plus: plus,
-  z: z
+  z: 3
 };
 
 let concat = "ab";