allow coercing unboxed with payload to primitive when applicable

Author: zth

jscomp/ml/ctype.ml

@@ -3956,8 +3956,8 @@ let rec subtype_rec env trace t1 t2 cstrs =
         ->
       (* type coercion for variants to primitives *)
       (match Variant_coercion.can_try_coerce_variant_to_primitive (extract_concrete_typedecl env t1) with
-      | Some constructors -> 
-        if constructors |> Variant_coercion.can_coerce_variant ~path then
+      | Some (constructors, unboxed) -> 
+        if constructors |> Variant_coercion.can_coerce_variant ~path ~unboxed then
           cstrs
         else 
           (trace, t1, t2, !univar_pairs)::cstrs

jscomp/ml/variant_coercion.ml

@@ -6,15 +6,28 @@ let can_coerce_path (path : Path.t) =
   || Path.same path Predef.path_int
   || Path.same path Predef.path_float
 
-let can_coerce_variant ~(path : Path.t)
+let check_paths_same p1 p2 target_path =
+  Path.same p1 target_path && Path.same p2 target_path
+
+let can_coerce_variant ~(path : Path.t) ~unboxed
     (constructors : Types.constructor_declaration list) =
   constructors
   |> List.for_all (fun (c : Types.constructor_declaration) ->
          let args = c.cd_args in
-         let payload = Ast_untagged_variants.process_tag_type c.cd_attributes in
+         let asPayload =
+           Ast_untagged_variants.process_tag_type c.cd_attributes
+         in
          match args with
+         | Cstr_tuple [{desc = Tconstr (p, [], _)}] when unboxed ->
+           let path_same = check_paths_same p path in
+           (* unboxed String(string) :> string *)
+           path_same Predef.path_string
+           || (* unboxed Number(float) :> float *)
+           path_same Predef.path_float
          | Cstr_tuple [] -> (
-           match payload with
+           (* Check that @as payloads match with the target path to coerce to.
+              No @as means the default encoding, which is string *)
+           match asPayload with
            | None | Some (String _) -> Path.same path Predef.path_string
            | Some (Int _) -> Path.same path Predef.path_int
            | Some (Float _) -> Path.same path Predef.path_float
@@ -24,10 +37,10 @@ let can_coerce_variant ~(path : Path.t)
 let can_try_coerce_variant_to_primitive
     ((_, p, typedecl) : Path.t * Path.t * Types.type_declaration) =
   match typedecl with
-  | {type_kind = Type_variant constructors; type_params = []}
+  | {type_kind = Type_variant constructors; type_params = []; type_attributes}
     when Path.name p <> "bool" ->
     (* bool is represented as a variant internally, so we need to account for that *)
-    Some constructors
+    Some (constructors, type_attributes |> Ast_untagged_variants.has_untagged)
   | _ -> None
 
 let variant_representation_matches (c1_attrs : Parsetree.attributes)