pr comments

Author: zth

compiler/ml/ast_untagged_variants.ml

@@ -71,7 +71,7 @@ type block_type =
   | ObjectType
   | UnknownType
 
-let block_type_to_string = function
+let block_type_to_user_visible_string = function
   | IntType -> "int"
   | StringType -> "string"
   | FloatType -> "float"
@@ -100,15 +100,15 @@ type tag = {name: string; tag_type: tag_type option}
 type block = {tag: tag; tag_name: string option; block_type: block_type option}
 type switch_names = {consts: tag array; blocks: block array}
 
-let tag_type_to_string = function
+let tag_type_to_user_visible_string = function
   | String _ -> "string"
   | Int _ -> "int"
   | Float _ -> "float"
   | BigInt _ -> "bigint"
   | Bool _ -> "bool"
   | Null -> "null"
   | Undefined -> "undefined"
-  | Untagged block_type -> block_type_to_string block_type
+  | Untagged block_type -> block_type_to_user_visible_string block_type
 
 let untagged = "unboxed"
 

compiler/ml/ctype.ml

@@ -72,11 +72,11 @@ let () =
 
 type subtype_context =
   | Generic of {errorCode: string}
-  | Primitive_coercion_target_variant_not_unboxed of {
+  | Coercion_target_variant_not_unboxed of {
       variant_name: Path.t;
       primitive: Path.t;
     }
-  | Primitive_coercion_target_variant_no_catch_all of {
+  | Coercion_target_variant_does_not_cover_type of {
       variant_name: Path.t;
       primitive: Path.t;
     }
@@ -3660,21 +3660,21 @@ let rec subtype_rec env trace t1 t2 cstrs =
             t2,
             !univar_pairs,
             Some
-              (Primitive_coercion_target_variant_not_unboxed
+              (Coercion_target_variant_not_unboxed
                  {variant_name = p; primitive = path}) )
           :: cstrs
         | Some (p, constructors, true) ->
           if
-            Variant_coercion.variant_has_catch_all_case constructors (fun p ->
-                Path.same p path)
+            Variant_coercion.variant_has_case_covering_type constructors
+              ~path_is_same_fn:(fun p -> Path.same p path)
           then cstrs
           else
             ( trace,
               t1,
               t2,
               !univar_pairs,
               Some
-                (Primitive_coercion_target_variant_no_catch_all
+                (Coercion_target_variant_does_not_cover_type
                    {variant_name = p; primitive = path}) )
             :: cstrs
         | None ->

compiler/ml/ctype.mli

@@ -21,11 +21,11 @@ open Types
 type subtype_context =
   | Generic of {errorCode: string}
       (** A generic subtype error, intended to be extended to be handled later. *)
-  | Primitive_coercion_target_variant_not_unboxed of {
+  | Coercion_target_variant_not_unboxed of {
       variant_name: Path.t;
       primitive: Path.t;
     }  (** Coercing a primitive to a variant that is not unboxed. *)
-  | Primitive_coercion_target_variant_no_catch_all of {
+  | Coercion_target_variant_does_not_cover_type of {
       variant_name: Path.t;
       primitive: Path.t;
     }

compiler/ml/printtyp.ml

@@ -1540,17 +1540,16 @@ let print_variant_runtime_representation_issue ppf variant_name
   | Inline_record_cannot_be_coerced {constructor_name} ->
     fprintf ppf
       "The constructor @{<info>%s@} of variant @{<info>%s@} has an inline \
-       record as payload. Inline records cannot be coerced."
+       record as payload. Currently, inline records cannot be coerced."
       constructor_name (Path.name variant_name)
-  | As_payload_cannot_be_coerced
+  | As_payload_not_elgible_for_coercion
       {constructor_name; as_payload; expected_typename} ->
     fprintf ppf
       "The constructor @{<info>%s@} of variant @{<info>%s@} has an \
        @{<info>@as@} payload that has a runtime representation of \
-       @{<info>%s@}, which is not compatible with the expected of \
-       @{<info>%s@}."
+       @{<info>%s@}, which is not compatible with the expected @{<info>%s@}."
       constructor_name (Path.name variant_name)
-      (Ast_untagged_variants.tag_type_to_string as_payload)
+      (Ast_untagged_variants.tag_type_to_user_visible_string as_payload)
       (Path.name expected_typename)
   | Mismatched_unboxed_payload _ -> ()
   | Mismatched_as_payload {constructor_name; expected_typename; as_payload} ->
@@ -1565,7 +1564,7 @@ let print_variant_runtime_representation_issue ppf variant_name
       fprintf ppf
         "an @{<info>@as@} payload that gives it the runtime type of \
          @{<info>%s@}."
-        (Ast_untagged_variants.tag_type_to_string payload));
+        (Ast_untagged_variants.tag_type_to_user_visible_string payload));
     fprintf ppf
       "@ That runtime representation is not compatible with the expected \
        runtime representation of @{<info>%s@}."
@@ -1704,16 +1703,15 @@ let report_subtyping_error ppf env tr1 txt1 tr2 ctx =
         fprintf ppf "@,@,@[<v 2>";
         match ctx with
         | Generic {errorCode} -> fprintf ppf "Error: %s" errorCode
-        | Primitive_coercion_target_variant_not_unboxed
-            {variant_name; primitive} ->
+        | Coercion_target_variant_not_unboxed {variant_name; primitive} ->
           fprintf ppf
             "@ The variant @{<info>%s@} is not unboxed, so it cannot be \
              coerced to a @{<info>%s@}. @ Fix this by adding the \
              @{<info>@unboxed@} attribute to the variant @{<info>%s@}."
             (Path.name variant_name) (Path.name primitive)
             (Path.name variant_name)
-        | Primitive_coercion_target_variant_no_catch_all
-            {variant_name; primitive} ->
+        | Coercion_target_variant_does_not_cover_type {variant_name; primitive}
+          ->
           fprintf ppf
             "@ The variant @{<info>%s@} is unboxed, but has no catch-all case \
              for the primitive @{<info>%s@}, and therefore does not cover all \

compiler/ml/variant_coercion.ml

@@ -8,7 +8,7 @@ type variant_runtime_representation_issue =
       expected_typename: Path.t;
       as_payload: Ast_untagged_variants.tag_type option;
     }
-  | As_payload_cannot_be_coerced of {
+  | As_payload_not_elgible_for_coercion of {
       constructor_name: string;
       expected_typename: Path.t;
       as_payload: Ast_untagged_variants.tag_type;
@@ -29,12 +29,12 @@ let can_coerce_primitive (path : Path.t) =
 let check_paths_same p1 p2 target_path =
   Path.same p1 target_path && Path.same p2 target_path
 
-let variant_has_catch_all_case
-    (constructors : Types.constructor_declaration list) path_is_same =
+let variant_has_case_covering_type
+    (constructors : Types.constructor_declaration list) ~path_is_same_fn =
   let has_catch_all_string_case (c : Types.constructor_declaration) =
     let args = c.cd_args in
     match args with
-    | Cstr_tuple [{desc = Tconstr (p, [], _)}] -> path_is_same p
+    | Cstr_tuple [{desc = Tconstr (p, [], _)}] -> path_is_same_fn p
     | _ -> false
   in
 
@@ -114,7 +114,7 @@ let variant_has_same_runtime_representation_as_target ~(target_path : Path.t)
                })
       | Some ((Null | Undefined | Bool _ | Untagged _) as as_payload) ->
         Some
-          (As_payload_cannot_be_coerced
+          (As_payload_not_elgible_for_coercion
              {
                constructor_name = Ident.name c.cd_id;
                as_payload;

tests/build_tests/super_errors/expected/variant_coercion_inline_record.res.expected

@@ -9,4 +9,4 @@
 
   Type x is not a subtype of string 
 
-  The constructor One of variant x has an inline record as payload. Inline records cannot be coerced.
+  The constructor One of variant x has an inline record as payload. Currently, inline records cannot be coerced.