Test primitive untagged cases before class checks

Why:
    A `switch` on an untagged variant ran its class checks before the
    `typeof` switch, so strings and numbers reached `v instanceof C` too. A
    class missing where the code runs, such as a user class or a newer
    `Intl` class, then threw for every value, even for the primitive cases.

When a variant has class cases, the arms of primitive kinds (string,
number, bigint, boolean, symbol) are now tested first, in an outer
`switch (typeof v)` whose default holds the class checks and the remaining
`object`/`function` arms. A class instance is never a primitive, so no value
changes arm. Primitive and other arms no longer share a body through
fall-through, since they sit in different switches. Variants with only an
array case keep the old form, since `Array.isArray` cannot throw.

JS modified (a class case beside primitive cases):
Example:
    @instanceof("Nope") type nope
    @unboxed type t = N(nope) | S(string) | F(float) | A(array<int>)
Before (js):
    if (v instanceof Nope) {
      return "N";
    }
    if (Array.isArray(v)) {
      return "A";
    }
    switch (typeof v) {
      case "string" :
        return v;
      case "number" :
        return "F";
    }
After (js):
    switch (typeof v) {
      case "string" :
        return v;
      case "number" :
        return "F";
      default:
        if (v instanceof Nope) {
          return "N";
        }
        if (Array.isArray(v)) {
          return "A";
        }
    }

Review: What does it cost? A second `switch (typeof v)` when there are
object or function arms too, and a body shared by a primitive and an object
arm is emitted twice (`awaitUser` in `UntaggedVariants.mjs`).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Fc7LEuyEfynjaKCVEBPmTF
Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

changes/untagged-typeof-first.polish.md

@@ -0,0 +1 @@
+- Test the primitive cases of an untagged variant before its class checks, so that strings and numbers skip `instanceof` and a class missing at run time no longer throws for them.

compiler/core/lam_compile.ml

@@ -853,10 +853,35 @@ let compile output_prefix =
       | _ -> false
     in
     let clause_is_not_typeof (tag, _) = tag_is_not_typeof tag in
+    let tag_is_primitive = function
+      | Variant_runtime.Payload_shape
+          ( IntType | FloatType | StringType | BigintType | BooleanType
+          | SymbolType ) ->
+        true
+      | _ -> false
+    in
+    (* Only class checks can throw (when the class is missing), so arrays,
+       recognized by [Array.isArray], keep the shorter form *)
+    let has_class_case =
+      List.exists
+        (function
+          | Variant_runtime.InstanceType (Class _) -> true
+          | _ -> false)
+        block_cases
+    in
     let switch ?default ?declaration e clauses =
       let not_typeof_clauses, typeof_clauses =
         List.partition clause_is_not_typeof clauses
       in
+      (* A class instance is never a primitive, so the primitive kinds can be
+         tested first: their values then skip the instance checks, which
+         throw when a class is missing at run time *)
+      let primitive_clauses, typeof_clauses =
+        if (not has_class_case) || not_typeof_clauses = [] then
+          ([], typeof_clauses)
+        else
+          List.partition (fun (tag, _) -> tag_is_primitive tag) typeof_clauses
+      in
       let has_object_typeof =
         List.exists
           (function
@@ -903,7 +928,12 @@ let compile output_prefix =
             ~else_:[build_if_chain rest]
         | _ -> (
           let typeof_switch () =
-            S.string_switch ?default ?declaration (E.typeof e) typeof_clauses
+            match (primitive_clauses, typeof_clauses) with
+            | _ :: _, [] -> S.block (Option.value default ~default:[])
+            | _ :: _, _ :: _ ->
+              S.string_switch ?default (E.typeof e) typeof_clauses
+            | [], _ ->
+              S.string_switch ?default ?declaration (E.typeof e) typeof_clauses
           in
           let guard =
             match (needs_null_guard, needs_array_guard) with
@@ -918,11 +948,18 @@ let compile output_prefix =
           | Some guard, None -> S.if_ (E.not guard) [typeof_switch ()]
           | None, _ -> typeof_switch ())
       in
-      build_if_chain not_typeof_clauses
+      match primitive_clauses with
+      | [] -> build_if_chain not_typeof_clauses
+      | _ ->
+        S.string_switch ?declaration (E.typeof e) primitive_clauses
+          ~default:[build_if_chain not_typeof_clauses]
     in
     let merge_cases tag1 tag2 =
-      (* only merge typeof cases, as instanceof cases are pulled out into if-then-else *)
-      not (tag_is_not_typeof tag1 || tag_is_not_typeof tag2)
+      (* only merge typeof cases, as instanceof cases are pulled out into
+         if-then-else. With instance cases, the primitive kinds are tested in
+         a switch of their own, so they share bodies only among themselves *)
+      (not (tag_is_not_typeof tag1 || tag_is_not_typeof tag2))
+      && ((not has_class_case) || tag_is_primitive tag1 = tag_is_primitive tag2)
     in
     cases
     |> compile_general_cases ~make_exp:E.tag_type ~eq_exp:mk_eq ~cxt ~switch

compiler/ml/UntaggedVariants.md

@@ -274,7 +274,19 @@ The payload arms compile in one of two forms.
   followed by `!(x instanceof C)` for every class case.
 - **Three or more arms**: an `if` chain of the instance checks, in the
   declaration order of the cases, then one `switch (typeof x)` over the other
-  arms.
+  arms. When a variant has class cases (not only arrays), the arms of
+  primitive kinds (string, number, bigint, boolean, symbol) come first, in an
+  outer `switch (typeof x)` whose default holds the rest; a class instance is
+  never a primitive, so this changes no outcome:
+
+  ```js
+  switch (typeof x) {
+    case "string": ...
+    default:
+      if (x instanceof Date) { ... }
+      else switch (typeof x) { case "object": ... }
+  }
+  ```
 
 In both forms a value of an instance case never lands in the object or
 function case. A class check is followed by `!(x instanceof D)` for every
@@ -340,8 +352,9 @@ Recognition trusts the type. A value that belongs to no case is not rejected:
 A value from another JavaScript realm fails every `instanceof` check and is
 recognized the same way (by the semantics of `instanceof`; not tested):
 recognition is local to a realm. A class that does not exist where the
-`switch` runs makes its check throw, for every value: the instance checks
-precede the `typeof` checks, so primitives reach them too.
+`switch` runs makes its check throw for every value that reaches it: in the
+`switch` form, objects, functions and primitives outside every case; in the
+two-arm form, every value when the class arm is declared first.
 
 - Implementation: `lam_compile.ml:compile_general_cases` (a complete match
   emits no check for its last clause).
@@ -547,6 +560,5 @@ had to answer, and the answers of rule 5:
 9. **Globals.** A shadowed class is read through `globalThis`. A missing
    class throws when the check runs (rule 10).
 
-Still open: a class imported from a module cannot be named; the `typeof`
-checks could precede the instance checks, so that a missing class affects
-only objects; and the typed arrays share one type (#8955).
+Still open: a class imported from a module cannot be named, and the typed
+arrays share one type (#8955).