Route mk_builtin through the folding constructors

mk_builtin's primitive case built its node directly, so a builtin was the
one place a term entered Lambda without passing the constructor that
normalizes it. It now goes through prim.

That moves folding from the optimizer passes to construction, and the
integer switcher plans over the set of distinct actions it is handed, so
what it sees changes. The two cases added here are what that cost and
bought. In the first, `10 + 10` merges with two `20` arms and four
branches with both results duplicated collapse to two with neither. In
the second the same merge drops the action count below the density the
switcher wants for a jump table, and a switch becomes a chain of
comparisons. Both plans are correct in both cases; only the emitted code
differs, and the snapshots are here so a future change to when folding
happens shows its win and its cost in the same diff.

Signed-off-by: Cristiano Calcagno <ccrisccris@gmail.com>

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

Author: cristianoc

CHANGELOG.md

@@ -68,6 +68,7 @@
 
 #### :house: Internal
 
+- Normalize Lambda terms where they are built: a match guard stays structured data until its fallthrough is known, and `apply` and `mk_builtin` go through the folding constructors. https://github.com/rescript-lang/rescript/pull/8615
 - Merge the duplicate Lam intermediate representation into Lambda, removing the conversion layer and obsolete supporting infrastructure. Lambda is now a single private, normalized representation, with generated JavaScript remaining semantically unchanged. https://github.com/rescript-lang/rescript/pull/8608
 - Add genType and source map controls and output to the developer playground. https://github.com/rescript-lang/rescript/pull/8448
 - Rework the object-type representation end to end: object rows are plain field chains carrying a per-field mutability state (no phantom setter members), object literals are typed directly and property access and assignment are first-class AST and Lambda nodes shared between the Lambda and JS pipelines, and dead class-system remnants (the field-presence lattice, the class-abbreviation memo on object types, method-send typing) are removed. https://github.com/rescript-lang/rescript/pull/8597

compiler/ml/lambda.ml

@@ -1264,7 +1264,7 @@ let sequand l r = if_ l r lambda_false
 
 let mk_builtin b args loc =
   match b with
-  | Primitive p -> Lprim {primitive = p; args; loc}
+  | Primitive p -> prim ~primitive:p ~args loc
   | Constant c -> (
     match args with
     | [] -> Lconst c

tests/tests/src/switch_action_count_test.mjs

@@ -0,0 +1,35 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function improves_when_merged(value) {
+  if (value > 3 || value < 1) {
+    return 99;
+  } else {
+    return 20;
+  }
+}
+
+function effect(s) {
+  console.log(s);
+}
+
+function regresses_when_merged(x) {
+  if (x > 4 || x < 1) {
+    if (x !== 5) {
+      console.log("s");
+    } else {
+      console.log("r");
+    }
+  } else if (x >= 4) {
+    console.log("q");
+  } else {
+    console.log("d");
+  }
+}
+
+export {
+  improves_when_merged,
+  effect,
+  regresses_when_merged,
+}
+/* No side effect */

tests/tests/src/switch_action_count_test.res

@@ -0,0 +1,48 @@
+// The integer switcher plans over the set of *distinct* actions it is handed:
+// given enough of them across a dense range it emits a jump table, otherwise
+// it tests intervals. That count depends on how far the term has been
+// normalized when it arrives, because normalization merges arms that were
+// written apart.
+//
+// Folding now happens at construction, so the switcher sees merged arms.
+// These two cases are what that cost, and bought, when mk_builtin started
+// folding: across the runtime, Belt and every other test module the output
+// was unchanged, and only these two moved. Both plans are correct in each
+// case; only the emitted code differs.
+//
+// They stay here because the same sensitivity applies to any future change in
+// where normalization happens, and to the switcher's own thresholds - see the
+// `dense` predicate in switch.ml, where `switch_min` is what refuses the jump
+// table below.
+
+// Improvement: `10 + 10` merges with the two `20` arms, so three actions
+// become one, and four branches with `20` and `99` each duplicated collapse
+// to two branches with neither duplicated.
+let improves_when_merged = value =>
+  switch value {
+  | 1 => 10 + 10
+  | 2 => 20
+  | 3 => 20
+  | _ => 99
+  }
+
+// Regression: the same merge drops the test count from three to two, below
+// `switch_min`, so `dense` refuses the jump table and this becomes a chain of
+// comparisons. The density check itself still passes; it is the minimum-tests
+// floor that rejects it.
+let effect = s => Console.log(s)
+
+let regresses_when_merged = x =>
+  switch x {
+  | 1 => effect("d")
+  | 2 => effect("d")
+  | 3 =>
+    if 3 > 2 {
+      effect("d")
+    } else {
+      effect("z")
+    }
+  | 4 => effect("q")
+  | 5 => effect("r")
+  | _ => effect("s")
+  }