Untagged variants: fix pm with overlap. (#6125)

* Untagged variants: fix pm with string overlap.

TODO: There should be something similar with int.

Fixes: #6123

* Other case of overlap: int and float.

* Add test for number overlap.

* Add case of object overlap.

* Handle object overlap.

* Unrelated: leftover instanceof.

* Logic more readable.

* Simplify object overlap.

* rename

Author: cristianoc

jscomp/core/js_exp_make.ml

@@ -776,13 +776,39 @@ let is_type_number ?comment (e : t) : t =
   string_equal ?comment (typeof e) (str "number")
 
 let rec is_a_literal_case ~(literal_cases : Lambda.literal list) ~block_cases (e:t) : t =
-  let is_literal_case (l:Lambda.literal) : t = bin EqEqEq e (literal l) in
-  let is_block_case (c:Lambda.block_type) : t = match c with
-  | StringType -> bin NotEqEq (typeof e) (str "string")
-  | IntType -> bin NotEqEq (typeof e) (str "number")
-  | FloatType -> bin NotEqEq (typeof e) (str "number")
-  | Array ->  not (bin InstanceOf e (str "Array" ~delim:DNoQuotes))
-  | Object ->  { expression_desc = Bin (NotEqEq, typeof e, str "object"); comment=None }
+  let literals_overlaps_with_string () = 
+    Ext_list.exists literal_cases (function
+      | String _ -> true
+      | l -> false ) in
+  let literals_overlaps_with_number () = 
+    Ext_list.exists literal_cases (function
+      | Int _ | Float _ -> true
+      | l -> false ) in
+  let literals_overlaps_with_object () = 
+    Ext_list.exists literal_cases (function
+      | Null -> true
+      | l -> false ) in
+  let (==) x y = bin EqEqEq x y in
+  let (!=) x y = bin NotEqEq x y in
+  let (||) x y = bin Or x y in
+  let (&&) x y = bin And x y in
+  let is_literal_case (l:Lambda.literal) : t =  e == (literal l) in
+  let is_not_block_case (c:Lambda.block_type) : t = match c with
+  | StringType when literals_overlaps_with_string () = false  (* No overlap *) -> 
+    (typeof e) != (str "string")
+  | IntType when literals_overlaps_with_number () = false ->
+    (typeof e) != (str "number")
+  | FloatType when literals_overlaps_with_number () = false ->
+    (typeof e) != (str "number")
+  | Array -> 
+    not (is_array e)
+  | Object when literals_overlaps_with_object () = false ->
+    (typeof e) != (str "object")
+  | Object (* overlap *) ->
+    e == nil || (typeof e) != (str "object")
+  | StringType (* overlap *)
+  | IntType (* overlap *)
+  | FloatType (* overlap *)
   | Unknown ->
     (* We don't know the type of unknown, so we need to express:
        this is not one of the literals *)
@@ -793,14 +819,14 @@ let rec is_a_literal_case ~(literal_cases : Lambda.literal list) ~block_cases (e
       | l1 :: others ->
         let is_literal_1 = is_literal_case l1 in
         Ext_list.fold_right others is_literal_1 (fun literal_n acc ->
-          bin Or (is_literal_case literal_n) acc
+          (is_literal_case literal_n) || acc
         )
     )
   in
   match block_cases with
-  | [c] -> is_block_case c
+  | [c] -> is_not_block_case c
   | c1 :: (_::_ as rest) ->
-    bin And (is_block_case c1) (is_a_literal_case ~literal_cases ~block_cases:rest e)
+    (is_not_block_case c1) && (is_a_literal_case ~literal_cases ~block_cases:rest e)
   | [] -> assert false
 
 let is_int_tag ?(has_null_undefined_other=(false, false, false)) (e : t) : t =

jscomp/test/UntaggedVariants.js

@@ -2,7 +2,7 @@
 
 
 function classify(x) {
-  if (typeof x !== "string" && typeof x !== "number") {
+  if (x === "A" && typeof x !== "number") {
     return "A";
   } else if (typeof x === "number") {
     return "An integer";
@@ -76,7 +76,7 @@ var Truthy = {
 };
 
 function classify$1(x) {
-  if (typeof x !== "object") {
+  if (x === null || typeof x !== "object") {
     if (x === null) {
       return "null";
     } else {
@@ -108,7 +108,7 @@ var Unknown = {
 };
 
 function classify$3(x) {
-  if (typeof x !== "object" && typeof x !== "number" && typeof x !== "string") {
+  if (typeof x !== "object" && typeof x !== "number" && (x === "C" || x === "B" || x === "A" || x === "D")) {
     switch (x) {
       case "A" :
           return "a";
@@ -173,7 +173,7 @@ var WithArray = {
 };
 
 function classify$6(x) {
-  if (!(x instanceof Array) && typeof x !== "object" && typeof x !== "number" && typeof x !== "string") {
+  if (!Array.isArray(x) && (x === null || typeof x !== "object") && typeof x !== "number" && typeof x !== "string") {
     switch (x) {
       case false :
           return "JSONFalse";
@@ -235,6 +235,63 @@ var TrickyNested = {
   check: check
 };
 
+function checkEnum(e) {
+  if (!(e === "Two" || e === "One" || e === "Three")) {
+    return "Something else..." + e;
+  }
+  switch (e) {
+    case "One" :
+        return "One!";
+    case "Two" :
+        return "Two";
+    case "Three" :
+        return "Threeeee";
+    
+  }
+}
+
+var OverlapString = {
+  checkEnum: checkEnum
+};
+
+function checkEnum$1(e) {
+  if (!(e === "Two" || e === 1.0 || e === "Three")) {
+    return "Something else...";
+  }
+  switch (e) {
+    case 1.0 :
+        return "One!";
+    case "Two" :
+        return "Two";
+    case "Three" :
+        return "Threeeee";
+    
+  }
+}
+
+var OverlapNumber = {
+  checkEnum: checkEnum$1
+};
+
+function checkEnum$2(e) {
+  if (!(e === null || typeof e !== "object")) {
+    return "Object...";
+  }
+  switch (e) {
+    case null :
+        return "One!";
+    case "Two" :
+        return "Two";
+    case "Three" :
+        return "Threeeee";
+    
+  }
+}
+
+var OverlapObject = {
+  checkEnum: checkEnum$2
+};
+
 var i = 42;
 
 var i2 = 42.5;
@@ -269,4 +326,7 @@ exports.OnlyBlocks = OnlyBlocks;
 exports.WithArray = WithArray;
 exports.Json = Json;
 exports.TrickyNested = TrickyNested;
+exports.OverlapString = OverlapString;
+exports.OverlapNumber = OverlapNumber;
+exports.OverlapObject = OverlapObject;
 /* l2 Not a pure module */

jscomp/test/UntaggedVariants.res

@@ -196,3 +196,42 @@ module TrickyNested = {
     | _ => 42
     }
 }
+
+module OverlapString = {
+  @unboxed
+  type enum = One | Two | Three | FutureAddedValue(string)
+
+  let checkEnum = e =>
+    switch e {
+    | One => "One!"
+    | Two => "Two"
+    | Three => "Threeeee"
+    | FutureAddedValue(s) => "Something else..." ++ s
+    }
+}
+
+module OverlapNumber = {
+  @unboxed
+  type enum = | @as(1.0) One | Two | Three | FutureAddedValue(float)
+
+  let checkEnum = e =>
+    switch e {
+    | One => "One!"
+    | Two => "Two"
+    | Three => "Threeeee"
+    | FutureAddedValue(_) => "Something else..."
+    }
+}
+
+module OverlapObject = {
+  @unboxed
+  type enum = | @as(null) One | Two | Three | Object({x: int})
+
+  let checkEnum = e =>
+    switch e {
+    | One => "One!"
+    | Two => "Two"
+    | Three => "Threeeee"
+    | Object(_) => "Object..."
+    }
+}