Shrink the stored layout to its honest content

Review of the representation changes found derived data stored beside
its source and duplicate derivations:

- variant_layout collapses to the constructors array. The by-name map
  duplicated every case (and the names inside them), and the dispatch
  field was derivable; both are now computed by accessors, with the
  dispatch derived at its single consumer in Matching.
- cstr_transparent was derivable from cstr_layout plus the unboxed
  attribute once descriptions carried their layout; it is a Datarepr
  predicate again, now environment-free.
- Construction in Translcore reads the constructor's layout entry
  (Datarepr.constructor_case) instead of re-deriving the tag and block
  runtime from attributes, closing the last spot where construction and
  matching could derive representation independently.
- Parmatch's full_match compares against the layout's length instead of
  looking the declaration up in the environment; the block-count folds
  in Translcore, Matching, and Datarepr use one Variant_runtime helper;
  js_dump drops a tautological num_nonconst test.
- The type-equation re-exports in Ast_untagged_variants are gone:
  consumers reference Variant_runtime directly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YWw5GW8t4UDEWAzoqcDMkE

Author: cristianoc

compiler/core/j.ml

@@ -244,7 +244,7 @@ and case_clause = {
   source_loc: Location.t option;
 }
 
-and string_clause = Ast_untagged_variants.tag_type * case_clause
+and string_clause = Variant_runtime.tag_type * case_clause
 and int_clause = int * case_clause
 and label = string
 

compiler/core/js_dump.ml

@@ -970,7 +970,7 @@ and expression_desc cxt ~(level : int) f x : cxt =
   | Caml_block (el, _, ((Blk_extension | Blk_record_ext _) as ext)) ->
     expression_desc cxt ~level f (exn_block_as_obj ~stack:false el ext)
   | Caml_block (el, _, Blk_record_inlined p) ->
-    let {Ast_untagged_variants.tag; tag_name; untagged} = p.runtime in
+    let {Variant_runtime.tag; tag_name; untagged} = p.runtime in
     let objs =
       let tails =
         Ext_list.combine_array p.fields el (fun (i, opt) -> (Js_op.Lit i, opt))
@@ -994,7 +994,7 @@ and expression_desc cxt ~(level : int) f x : cxt =
     expression_desc cxt ~level f (Object (None, objs))
   | Caml_block (el, _, Blk_constructor p) ->
     let not_is_cons = p.name <> Literals.cons in
-    let {Ast_untagged_variants.tag; tag_name; untagged} = p.runtime in
+    let {Variant_runtime.tag; tag_name; untagged} = p.runtime in
     let tag_type = tag.tag_type in
     let tag_name = Option.value tag_name ~default:L.tag in
     let objs =
@@ -1010,7 +1010,7 @@ and expression_desc cxt ~(level : int) f x : cxt =
              [(name_symbol, E.str p.name)]
            else [])
       in
-      if untagged || (not_is_cons = false && p.num_nonconst = 1) then tails
+      if untagged || not_is_cons = false then tails
       else
         ( Js_op.Lit tag_name,
           (* TAG:xx *)
@@ -1689,7 +1689,7 @@ and statement_desc top cxt f (s : J.statement_desc) : cxt =
     let cxt = P.paren_group f 1 (fun _ -> expression ~level:0 cxt f e) in
     P.space f;
     P.brace_vgroup f 1 (fun _ ->
-        let pp_as_value f (tag_type : Ast_untagged_variants.tag_type) =
+        let pp_as_value f (tag_type : Variant_runtime.tag_type) =
           let e = E.tag_type tag_type in
           ignore @@ expression_desc cxt ~level:0 f e.expression_desc
         in

compiler/core/js_exp_make.ml

@@ -1358,7 +1358,7 @@ let rec float_equal ?comment (e0 : t) (e1 : t) : t =
 let int_equal = float_equal
 
 let tag_type = function
-  | Ast_untagged_variants.String s -> str s ~delim:DStarJ
+  | Variant_runtime.String s -> str s ~delim:DStarJ
   | Int i -> small_int i
   | Float f -> float f
   | BigInt i ->
@@ -1374,7 +1374,7 @@ let tag_type = function
   | Untagged FunctionType -> str "function"
   | Untagged StringType -> str "string"
   | Untagged (InstanceType i) ->
-    str (Ast_untagged_variants.Instance.to_string i) ~delim:DNoQuotes
+    str (Variant_runtime.Instance.to_string i) ~delim:DNoQuotes
   | Untagged ObjectType -> str "object"
   | Untagged UnknownType ->
     (* TODO: this should not happen *)
@@ -1395,7 +1395,7 @@ let rec emit_check (check : t Ast_untagged_variants.Dynamic_checks.t) =
   | TypeOf x -> typeof (emit_check x)
   | IsInstanceOf (Array, x) -> is_array (emit_check x)
   | IsInstanceOf (instance, x) ->
-    let instance_name = Ast_untagged_variants.Instance.to_string instance in
+    let instance_name = Variant_runtime.Instance.to_string instance in
     instanceof (emit_check x) (str instance_name ~delim:DNoQuotes)
   | Not x -> not (emit_check x)
   | Expr x -> x

compiler/core/js_exp_make.mli

@@ -165,7 +165,7 @@ val extension_assign : t -> int32 -> string -> t -> t
 
 val assign : ?comment:string -> t -> t -> t
 
-val tag_type : Ast_untagged_variants.tag_type -> t
+val tag_type : Variant_runtime.tag_type -> t
 
 val emit_check : t Ast_untagged_variants.Dynamic_checks.t -> t
 
@@ -187,8 +187,8 @@ val is_type_number : ?comment:string -> t -> t
 val is_int_tag : ?has_null_undefined_other:bool * bool * bool -> t -> t
 
 val is_a_literal_case :
-  literal_cases:Ast_untagged_variants.tag_type list ->
-  block_cases:Ast_untagged_variants.block_type list ->
+  literal_cases:Variant_runtime.tag_type list ->
+  block_cases:Variant_runtime.block_type list ->
   t ->
   t
 

compiler/core/js_of_lam_variant.ml

@@ -40,7 +40,7 @@ let eval (arg : J.expression) (dispatches : (string * string) list) : E.t =
         [
           S.string_switch arg
             (Ext_list.map dispatches (fun (s, r) ->
-                 ( Ast_untagged_variants.String s,
+                 ( Variant_runtime.String s,
                    J.
                      {
                        switch_body = [S.return_stmt (E.str r)];
@@ -81,7 +81,7 @@ let eval_as_event (arg : J.expression)
               S.string_switch
                 (E.poly_var_tag_access arg)
                 (Ext_list.map dispatches (fun (s, r) ->
-                     ( Ast_untagged_variants.String s,
+                     ( Variant_runtime.String s,
                        J.
                          {
                            switch_body = [S.return_stmt (E.str r)];
@@ -110,7 +110,7 @@ let eval_as_int (arg : J.expression) (dispatches : (string * int) list) : E.t =
         [
           S.string_switch arg
             (Ext_list.map dispatches (fun (s, r) ->
-                 ( Ast_untagged_variants.String s,
+                 ( Variant_runtime.String s,
                    J.
                      {
                        switch_body = [S.return_stmt (E.int (Int32.of_int r))];

compiler/core/js_stmt_make.ml

@@ -142,7 +142,7 @@ let int_switch ?(comment : string option)
 let string_switch ?(comment : string option)
     ?(declaration : (J.property * Ident.t) option) ?(default : J.block option)
     (e : J.expression)
-    (clauses : (Ast_untagged_variants.tag_type * J.case_clause) list) : t =
+    (clauses : (Variant_runtime.tag_type * J.case_clause) list) : t =
   match e.expression_desc with
   | Str {txt} -> (
     let continuation =

compiler/core/js_stmt_make.mli

@@ -73,7 +73,7 @@ val string_switch :
   ?declaration:Lam_compat.let_kind * Ident.t ->
   ?default:J.block ->
   J.expression ->
-  (Ast_untagged_variants.tag_type * J.case_clause) list ->
+  (Variant_runtime.tag_type * J.case_clause) list ->
   t
 
 val declare_variable :

compiler/core/lam.ml

@@ -295,7 +295,7 @@ let switch lam (lam_switch : lambda_switch) : t =
           match key with
           | Lambda.Switch_int ordinal when ordinal = i -> Some action
           | Switch_constructor
-              (Constant {tag_type = Some (Ast_untagged_variants.Int value)})
+              (Constant {tag_type = Some (Variant_runtime.Int value)})
             when comment = None && value = i ->
             Some action
           | Switch_int _ | Switch_constructor _ -> None)

compiler/core/lam_compile.ml

@@ -218,7 +218,7 @@ let dispatch_info = function
   | Lambda.Switch_direct -> (Js_dump_lit.tag, [], [], (false, false, false))
   | Switch_variant
       {
-        Ast_untagged_variants.tag_name;
+        Variant_runtime.tag_name;
         block_types;
         literal_tags;
         has_null;
@@ -690,7 +690,7 @@ let compile output_prefix =
     List.fold_right
       (fun (key, lam) acc ->
         match (tag_of_switch_key key, acc) with
-        | Some {Ast_untagged_variants.tag_type = Some t}, Some string_table ->
+        | Some {Variant_runtime.tag_type = Some t}, Some string_table ->
           Some ((t, lam) :: string_table)
         | Some {name; tag_type = None}, Some string_table ->
           Some ((String name, lam) :: string_table)
@@ -786,9 +786,7 @@ let compile output_prefix =
               && List.length sw_consts = 0
               && eq_default sw_num_default sw_blocks_default
             then
-              let has_null_case =
-                List.mem Ast_untagged_variants.Null literal_cases
-              in
+              let has_null_case = List.mem Variant_runtime.Null literal_cases in
               compile_cases ~untagged ~cxt
                 ~switch_exp:(if untagged then e else E.tag ~name:tag_name e)
                 ~block_cases ~has_null_case ~default:sw_blocks_default sw_blocks
@@ -838,7 +836,7 @@ let compile output_prefix =
          ~switch_exp ~default
   and compile_untagged_cases ~cxt ~switch_exp ~default ~block_cases
       ~has_null_case cases =
-    let mk_eq (i : Ast_untagged_variants.tag_type option) x j y =
+    let mk_eq (i : Variant_runtime.tag_type option) x j y =
       let check =
         match (i, j) with
         | Some tag_type, _ ->
@@ -852,7 +850,7 @@ let compile output_prefix =
       E.emit_check check
     in
     let tag_is_not_typeof = function
-      | Ast_untagged_variants.Untagged (InstanceType _) -> true
+      | Variant_runtime.Untagged (InstanceType _) -> true
       | _ -> false
     in
     let clause_is_not_typeof (tag, _) = tag_is_not_typeof tag in
@@ -863,21 +861,21 @@ let compile output_prefix =
       let has_object_typeof =
         List.exists
           (function
-            | Ast_untagged_variants.Untagged ObjectType, _ -> true
+            | Variant_runtime.Untagged ObjectType, _ -> true
             | _ -> false)
           typeof_clauses
       in
       let clauses_have_array_case =
         List.exists
           (function
-            | Ast_untagged_variants.Untagged (InstanceType Array), _ -> true
+            | Variant_runtime.Untagged (InstanceType Array), _ -> true
             | _ -> false)
           not_typeof_clauses
       in
       let type_has_array_case =
         List.exists
           (function
-            | Ast_untagged_variants.InstanceType Array -> true
+            | Variant_runtime.InstanceType Array -> true
             | _ -> false)
           block_cases
       in
@@ -890,7 +888,7 @@ let compile output_prefix =
       in
       let rec build_if_chain remaining_clauses =
         match remaining_clauses with
-        | ( Ast_untagged_variants.Untagged (InstanceType instance_type),
+        | ( Variant_runtime.Untagged (InstanceType instance_type),
             {J.switch_body} )
           :: rest ->
           S.if_
@@ -930,7 +928,7 @@ let compile output_prefix =
         The [gen] can be elimiated when number of [cases] is less than 3
     *)
     let cases =
-      cases |> List.map (fun (s, l) -> (Ast_untagged_variants.String s, l))
+      cases |> List.map (fun (s, l) -> (Variant_runtime.String s, l))
     in
     match
       compile_lambda {lambda_cxt with continuation = NeedValue Not_tail} l

compiler/core/lam_constant_convert.ml

@@ -42,7 +42,7 @@ let rec convert_constant (const : Lambda.structured_constant) : Lam_constant.t =
     | Pt_module_alias -> Const_module_alias
     | Pt_shape_none -> Lam_constant.lam_none
     | Pt_assertfalse -> Const_int {i = 0l; comment = Pt_assertfalse}
-    | Pt_constructor {tag_type = Some (Ast_untagged_variants.Int v)} ->
+    | Pt_constructor {tag_type = Some (Variant_runtime.Int v)} ->
       (* A constructor represented as a number is a genuine number at
          runtime; folding relies on it being an ordinary int constant *)
       Const_int {i = Int32.of_int v; comment = None}