handle instanceof for untagged variants in code generator

Author: zth

jscomp/core/lam_compile.ml

@@ -762,18 +762,23 @@ and compile_untagged_cases ~cxt ~switch_exp ~default ~block_cases cases =
     in
     E.emit_check check
   in
-  let is_array (l, _) = l = Ast_untagged_variants.Untagged (InstanceType Array) in
+  let is_not_typeof (l, _) = match l with 
+  | Ast_untagged_variants.Untagged (InstanceType _) -> true
+  | _ -> false in
   let switch ?default ?declaration e clauses =
-    let array_clauses = Ext_list.filter clauses is_array in
-    match array_clauses with
-    | [(l, {J.switch_body})] when List.length clauses > 1 ->
-      let rest = Ext_list.filter clauses (fun c -> not (is_array c)) in
+    let not_typeof_clauses = Ext_list.filter clauses is_not_typeof in
+    let typeof_clauses = Ext_list.filter clauses (fun c -> not (is_not_typeof c)) in
+    let rec build_if_chain remaining_clauses = (match remaining_clauses with 
+    | (Ast_untagged_variants.Untagged (InstanceType Array), {J.switch_body}) :: rest -> 
       S.if_ (E.is_array e)
         (switch_body)
-        ~else_:([S.string_switch ?default ?declaration (E.typeof e) rest])
-    | _ :: _ :: _ -> assert false (* at most 1 array case *)
-    | _ ->
-      S.string_switch ?default ?declaration (E.typeof e) clauses in
+        ~else_:([build_if_chain rest])
+    | (Ast_untagged_variants.Untagged (InstanceType instanceType), {J.switch_body}) :: rest -> 
+      S.if_ (E.instanceof e (E.js_global (Ast_untagged_variants.Instance.to_string instanceType)))
+        (switch_body)
+        ~else_:([build_if_chain rest])
+    | _ -> S.string_switch ?default ?declaration (E.typeof e) typeof_clauses) in
+    build_if_chain not_typeof_clauses in
   cases |> compile_general_cases
     ~make_exp: E.tag_type
     ~eq_exp: mk_eq

jscomp/test/UntaggedVariants.js

@@ -296,16 +296,16 @@ module OptionUnboxingHeuristic = {
 
 module TestFunctionCase = {
   @unboxed
-  type t = Array(array<int>) | Record({x:int}) | Function((. int) => int)
+  type t = Array(array<int>) | Record({x: int}) | Function((. int) => int)
 
   let classify = v =>
     switch v {
     | Record({x}) => x
     | Array(a) => a[0]
-    | Function(f) => f(. 3) 
+    | Function(f) => f(. 3)
     }
 
-    let ff = Function((. x) => x+1)
+  let ff = Function((. x) => x + 1)
 }
 
 module ComplexPattern = {
@@ -336,4 +336,38 @@ module ComplexPattern = {
     | Array([True, False, Array([String("My name is"), Number(10.)])]) => Js.log("yup")
     | _ => Js.log("Nope...")
     }
-}
+}
+
+module PromiseSync = {
+  type user = {name: string}
+
+  @unboxed type value = Sync(user) | Async(promise<user>) | Name(string)
+
+  let getUserName = async (u: value) =>
+    switch u {
+    | Sync(user) => user.name
+    | Async(userPromise) =>
+      let user = await userPromise
+      user.name
+    | Name(name) => name
+    }
+
+  let awaitUser = async (u: value) =>
+    switch u {
+    | Async(userPromise) =>
+      let user = await userPromise
+      user.name
+    | _ => "dummy"
+    }
+}
+
+module Arr = {
+  @unboxed type arr = Array(array<string>) | String(string) | Promise(promise<string>)
+
+  let classify = async (a: arr) =>
+    switch a {
+    | Array(arr) => Js.log(arr->Belt.Array.joinWith("-"))
+    | String(s) => Js.log(s)
+    | Promise(p) => Js.log(await p)
+    }
+}