diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6940948780..3e77acfd55 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 a0c0b46d05..6b319d1822 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 019d233458..a3c1e9d06c 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 54dac1787b..d8cd309532 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 ad7e08c002..dfb703f37d 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 47b41b1789..17ef67d952 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 49027c8565..fe248d849e 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 320ecd4164..058af703b8 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 2b8da1e78a..9696587e2c 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 8ab29e4ca7..e8ec2a51b1 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 33ceff7cd0..db4de083e9 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 18467698ad..a1ea361b25 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 561c9e3125..238045e9f4 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 3c9122fba0..dd692e8842 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 8dd296b270..987d844ddd 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 3a4ae0f904..efe4d9802b 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 681f33a98b..adbe108c1b 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 11043f688a..7c9c9a7a0a 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 3e6be9bc24..6a55f5d026 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 34577f8c6b..65f54fb4e3 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 ac27a889db..51a529dd30 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 ca17405188..6b701e35e7 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 4bc6c918bc..15fe3c580f 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 5bb18b893b..8c43e67f24 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 e5d8b12954..bf094dafb1 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 d839ca7232..ead63203f0 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 987895a6e7..ec3bcdbe91 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 10c14996b3..5f346368a2 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 0df33e30b3..46de835200 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 87464a30df..f189982ffb 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 be46521619..ec8122f7ea 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 ed1ec40fed..9606f24960 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 7448a29351..b5aa2e665a 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 9f149a2cb0..6add70d515 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 f19b9d0fd8..38f42a7db0 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 0fcbc8857b..b112d87e98 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 59022e564c..5e4c70a5fa 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 64f2fa23b6..2302a330f5 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 948ecd410a..b622586bcd 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 bbe794b052..89cf2934a9 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 e89588197d..1e9d407f78 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 87ea7737ee..951349b0e5 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";