Support bool untagged variants

Author: DZakh

jscomp/core/js_exp_make.ml

@@ -807,6 +807,7 @@ let tag_type = function
   | Untagged FloatType -> str "number"
   | Untagged FunctionType -> str "function"
   | Untagged StringType -> str "string"
+  | Untagged BooleanType -> str "boolean"
   | Untagged ArrayType -> str "Array" ~delim:DNoQuotes
   | Untagged ObjectType -> str "object"
   | Untagged UnknownType ->

jscomp/ml/ast_untagged_variants.ml

@@ -5,6 +5,7 @@ type untaggedError =
   | AtMostOneFunction
   | AtMostOneString
   | AtMostOneNumber
+  | AtMostOneBoolean
   | DuplicateLiteral of string
   | ConstructorMoreThanOneArg of string
 type error =
@@ -34,6 +35,7 @@ let report_error ppf =
       | AtMostOneString -> "At most one case can be a string type."
       | AtMostOneNumber ->
         "At most one case can be a number type (int or float)."
+      | AtMostOneBoolean -> "At most one case can be a boolean type."
       | DuplicateLiteral s -> "Duplicate literal " ^ s ^ "."
       | ConstructorMoreThanOneArg (name) -> "Constructor " ^ name ^ " has more than one argument.")
 
@@ -42,6 +44,7 @@ type block_type =
   | IntType
   | StringType
   | FloatType
+  | BooleanType
   | ArrayType
   | FunctionType
   | ObjectType
@@ -137,6 +140,9 @@ let get_block_type ~env (cstr : Types.constructor_declaration) :
   | true, Cstr_tuple [{desc = Tconstr (path, _, _)}]
     when Path.same path Predef.path_float ->
     Some FloatType
+  | true, Cstr_tuple [{desc = Tconstr (path, _, _)}]
+    when Path.same path Predef.path_bool ->
+    Some BooleanType
   | true, Cstr_tuple [{desc = Tconstr (path, _, _)}]
     when Path.same path Predef.path_array ->
     Some ArrayType
@@ -196,6 +202,7 @@ let checkInvariant ~isUntaggedDef ~(consts : (Location.t * tag) list)
   let functionTypes = ref 0 in
   let objectTypes = ref 0 in
   let stringTypes = ref 0 in
+  let booleanTypes = ref 0 in
   let numberTypes = ref 0 in
   let unknownTypes = ref 0 in
   let addStringLiteral ~loc s =
@@ -219,6 +226,8 @@ let checkInvariant ~isUntaggedDef ~(consts : (Location.t * tag) list)
       raise (Error (loc, InvalidUntaggedVariantDefinition AtMostOneFunction));
     if !stringTypes > 1 then
       raise (Error (loc, InvalidUntaggedVariantDefinition AtMostOneString));
+    if !booleanTypes > 1 then
+      raise (Error (loc, InvalidUntaggedVariantDefinition AtMostOneBoolean));
     if !numberTypes > 1 then
       raise (Error (loc, InvalidUntaggedVariantDefinition AtMostOneNumber));
     ()
@@ -253,6 +262,9 @@ let checkInvariant ~isUntaggedDef ~(consts : (Location.t * tag) list)
         | Some (IntType | FloatType) ->
           incr numberTypes;
           invariant loc name
+        | Some BooleanType ->
+          incr booleanTypes;
+          invariant loc name
         | Some StringType ->
           incr stringTypes;
           invariant loc name
@@ -315,6 +327,7 @@ module DynamicChecks = struct
   let function_ = Untagged FunctionType |> tag_type
   let string = Untagged StringType |> tag_type
   let number = Untagged IntType |> tag_type
+  let boolean = Untagged BooleanType |> tag_type
 
   let ( == ) x y = bin EqEqEq x y
   let ( != ) x y = bin NotEqEq x y
@@ -333,6 +346,11 @@ module DynamicChecks = struct
         | Int _ | Float _ -> true
         | _ -> false)
     in
+    let literals_overlaps_with_boolean () =
+      Ext_list.exists literal_cases (function
+        | Bool _ -> true
+        | _ -> false)
+    in
     let literals_overlaps_with_object () =
       Ext_list.exists literal_cases (function
         | Null -> true
@@ -348,6 +366,8 @@ module DynamicChecks = struct
         typeof e != number
       | FloatType when literals_overlaps_with_number () = false ->
         typeof e != number
+      | BooleanType when literals_overlaps_with_boolean () = false ->
+        typeof e != boolean
       | ArrayType -> not (is_array e)
       | FunctionType -> typeof e != function_
       | ObjectType when literals_overlaps_with_object () = false ->
@@ -356,6 +376,7 @@ module DynamicChecks = struct
       | StringType (* overlap *)
       | IntType (* overlap *)
       | FloatType (* overlap *)
+      | BooleanType (* overlap *)
       | UnknownType -> (
         (* We don't know the type of unknown, so we need to express:
            this is not one of the literals *)
@@ -396,7 +417,7 @@ module DynamicChecks = struct
   let add_runtime_type_check ~tag_type ~(block_cases : block_type list) x y =
     let has_array () = Ext_list.exists block_cases (fun t -> t = ArrayType) in
     match tag_type with
-    | Untagged (IntType | StringType | FloatType | FunctionType) ->
+    | Untagged (IntType | StringType | FloatType | BooleanType | FunctionType) ->
       typeof y == x
     | Untagged ObjectType ->
       if has_array () then typeof y == x &&& not (is_array y) else typeof y == x

jscomp/test/UntaggedVariants.js

@@ -134,6 +134,35 @@ module WithArray = {
     }
 }
 
+module WithBool = {
+  @unboxed
+  type t<'a> = String(string) | Float(float) | Bool(bool) | Object({name: string})
+
+  let classify = x =>
+    switch x {
+    | String(_) => "string"
+    | Float(_) => "int"
+    | Bool(true) => "true"
+    | Bool(_) => "boolean"
+    | Object({name}) => "Object" ++ name
+    }
+}
+
+module WithBoolAndConstants = {
+  @unboxed
+  type t<'a> =
+    | Bool(bool)
+    | @as(false) False
+    | @as(true) True
+
+  let classify = x =>
+    switch x {
+    | True => "true"
+    | False => "false"
+    | Bool(_) => "boolean"
+    }
+}
+
 module Json = {
   @unboxed
   type rec t =
@@ -296,16 +325,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 +365,4 @@ module ComplexPattern = {
     | Array([True, False, Array([String("My name is"), Number(10.)])]) => Js.log("yup")
     | _ => Js.log("Nope...")
     }
-}
+}