super_errors: add high-value sub-case fixtures from coverage audit

Coverage (`make coverage`) showed 53% line coverage across the
compiler; the lowest-coverage error-emitting modules are
ast_untagged_variants.ml (56%), typemod.ml (62%), includecore.ml (63%),
includemod.ml (68%), typedecl.ml (73%), error_message_utils.ml (75%).
A targeted audit of the report-side branches in error_message_utils.ml
flagged the following untested user-visible sub-cases:

- pattern_type_clash_polyvariant.res — `switch (x: int) { | #A => …}`
  trips a Pattern_type_clash with the polyvariant-vs-concrete trace.
- pattern_type_clash_tuple_arity.res — pattern `(a, b, c)` against a
  `(int, string)` value (tuple-arity mismatch path).
- labeled_fn_argument_type_clash.res — `f(~x="hi")` against
  `(~x: int) =>` hits FunctionArgument with an explicit label name
  (distinct from the existing optional-arg / record-field sub-cases).
- Iface_variant_extra_constructor (multi) — implementation declares
  one more constructor than the interface; covers the `Field_missing`
  branch where the impl is the side with the extra.

Catalog notes updated to enumerate the Expr_type_clash and
Pattern_type_clash trace-shape fixtures so future readers can
audit sub-case coverage without spelunking the source.

Author: JonoPrest

tests/ERROR_VARIANTS.md

@@ -67,11 +67,11 @@ Source: [typecore.ml:27](../compiler/ml/typecore.ml).
 | `Polymorphic_label` | ✓ | `polymorphic_label.res` | Pattern that instantiates a polymorphic record field: `({f: (f: int => int)}: t) =>` constrains the universal `'a` of `f: 'a. 'a => 'a` to `int => int`. |
 | `Constructor_arity_mismatch` | ✓ | `constructor_arity_mismatch.res`, `constructor_arity_mismatch_pattern.res`, `arity_mismatch*.res` | Triggers in both expression (4028) and pattern (1426) paths. |
 | `Label_mismatch` | ⚠ | — | typecore.ml:1543/3589. Defensive `try unify ty_res ty_expected with Unify -> Label_mismatch`. The only way to reach the unify is after label disambiguation (`type_label_a_list` / `type_label_pat` / `Wrong_name`-style logic), which always locks `ty_res` to a record type already unifiable with the expected. The unify therefore can't fail in practice — every reproduction hits `Wrong_name`, `Pattern_type_clash`, or `Expr_type_clash` instead. The constructor is a defensive leftover from the OCaml inheritance. |
-| `Pattern_type_clash` | ✓ | many `*_pattern_type_clash.res` etc. | Most-fired pattern error; covered through many fixtures but report-side sub-cases (option-vs-non-option trace, polyvariant context, etc.) remain partly untested. |
+| `Pattern_type_clash` | ✓ | many `*_pattern_type_clash.res` etc. | Most-fired pattern error. Sub-case fixtures: `pattern_matching_on_option_but_value_not_option.res` and `pattern_matching_on_value_but_is_option.res` (option-vs-non-option trace), `pattern_type_clash_polyvariant.res` (polyvariant tag against concrete type), `pattern_type_clash_tuple_arity.res` (tuple arity mismatch). |
 | `Or_pattern_type_clash` | ✓ | `or_pattern_type_clash.res` | |
 | `Multiply_bound_variable` | ✓ | `multiply_bound_variable.res` | |
 | `Orpat_vars` | ✓ | `orpat_vars_unbalanced.res` | |
-| `Expr_type_clash` | ✓ | many `*.res` | Most-fired expression error. Many trace-shape sub-cases (function-arg context, JSX, dict, async, polyvariant) covered piecemeal; sub-case coverage is the biggest open area for this variant. |
+| `Expr_type_clash` | ✓ | many `*.res` | Most-fired expression error. Trace-shape sub-cases covered: `if_return_type_mismatch.res` (IfReturn), `maybe_unwrap_option.res` (MaybeUnwrapOption), `string_concat_non_string.res` (StringConcat), `labeled_fn_argument_type_clash.res` (FunctionArgument with explicit label), `math_operator_*.res` (MathOperator family), `ternary_branch_mismatch.res`, `switch_different_types.res`, `try_catch_same_type.res`, `comparison_operator.res`, `array_item_type_mismatch.res`, `array_literal_passed_to_tuple.res`, `if_condition_mismatch.res`, `while_condition.res`, `for_loop_condition.res`, `assert_condition.res`, `function_call_mismatch.res`, `awaiting_non_promise.res`, multiple `jsx_*` fixtures. |
 | `Apply_non_function` | ✓ | `apply_non_function.res` | |
 | `Apply_wrong_label` | ✓ | `apply_wrong_label.res` | |
 | `Label_multiply_defined` | ✓ | `label_multiply_defined_literal.res` | |

tests/build_tests/super_errors/expected/labeled_fn_argument_type_clash.res.expected

@@ -0,0 +1,13 @@
+
+  We've found a bug for you!
+  /.../fixtures/labeled_fn_argument_type_clash.res:3:14-17
+
+  1 │ let f = (~x: int) => x
+  2 │ 
+  3 │ let _ = f(~x="hi")
+  4 │ 
+
+  This has type: string
+  But this function argument ~x is expecting: int
+  
+  You can convert string to int with Int.fromString.

tests/build_tests/super_errors/expected/pattern_type_clash_polyvariant.res.expected

@@ -0,0 +1,12 @@
+
+  We've found a bug for you!
+  /.../fixtures/pattern_type_clash_polyvariant.res:3:5-6
+
+  1 │ let f = (x: int) =>
+  2 │   switch x {
+  3 │   | #A => 1
+  4 │   | _ => 0
+  5 │   }
+
+  This pattern matches values of type [? #A]
+  but a pattern was expected which matches values of type int

tests/build_tests/super_errors/expected/pattern_type_clash_tuple_arity.res.expected

@@ -0,0 +1,12 @@
+
+  We've found a bug for you!
+  /.../fixtures/pattern_type_clash_tuple_arity.res:3:5-13
+
+  1 │ let f = (x: (int, string)) =>
+  2 │   switch x {
+  3 │   | (a, b, c) => a + Int.fromString(b)->Option.getOr(0) + c
+  4 │   }
+  5 │ 
+
+  This pattern matches values of type ('a, 'b, 'c)
+  but a pattern was expected which matches values of type (int, string)

tests/build_tests/super_errors/fixtures/labeled_fn_argument_type_clash.res

@@ -0,0 +1,3 @@
+let f = (~x: int) => x
+
+let _ = f(~x="hi")

tests/build_tests/super_errors/fixtures/pattern_type_clash_polyvariant.res

@@ -0,0 +1,5 @@
+let f = (x: int) =>
+  switch x {
+  | #A => 1
+  | _ => 0
+  }

tests/build_tests/super_errors/fixtures/pattern_type_clash_tuple_arity.res

@@ -0,0 +1,4 @@
+let f = (x: (int, string)) =>
+  switch x {
+  | (a, b, c) => a + Int.fromString(b)->Option.getOr(0) + c
+  }

tests/build_tests/super_errors_multi/expected/Iface_variant_extra_constructor.expected

@@ -0,0 +1,19 @@
+===== Foo.res =====
+
+  We've found a bug for you!
+  /.../fixtures/Iface_variant_extra_constructor/Foo.res:1:1-18
+
+  1 │ type t = A | B | C
+  2 │ 
+
+  The implementation /.../fixtures/Iface_variant_extra_constructor/Foo.res
+  does not match the interface /.../fixtures/Iface_variant_extra_constructor/foo.cmi:
+  Type declarations do not match:
+    type t = A | B | C
+  is not included in
+    type t = A | B
+  /.../fixtures/Iface_variant_extra_constructor/Foo.resi:1:1-14:
+    Expected declaration
+  /.../fixtures/Iface_variant_extra_constructor/Foo.res:1:1-18:
+    Actual declaration
+  The field C is only present in the first declaration.

tests/build_tests/super_errors_multi/fixtures/Iface_variant_extra_constructor/Foo.res

@@ -0,0 +1 @@
+type t = A | B | C

tests/build_tests/super_errors_multi/fixtures/Iface_variant_extra_constructor/Foo.resi

@@ -0,0 +1 @@
+type t = A | B