Remove dead error variants and warning constructors

[JonoPrest]

Remove dead error variants and warning constructors

Cleanup follow-up to rescript-lang#8446. Splits dead-variant removals into two
principled categories:

1. Truly dead — variants with no raise site, transitively dead
   chains, or always-false guards. Declaration, raise, reporter, and
   any supporting helpers are deleted entirely.

2. Defensive unreachable — variants whose raise site exists but is
   provably unreachable from the ReScript parser (parser blocks the
   required AST shape, or a sibling check fires first). The raise site
   becomes assert false (* reason *) with a comment citing the specific
   blocker; the named variant and its reporter are deleted. This matches
   the existing typer-module convention (57 assert false uses across
   typecore/typedecl/typemod/typetexp; zero Location.raise_errorf
   calls in those four modules in master).

Variants that turned out to be reachable, or that I couldn't conclusively
prove unreachable, are kept as named variants — no code change to them.

Truly dead — declaration + raise + reporter all removed

ctype.ml (3 exceptions, never raised under compiler/):

• Tags of label * label
• Recursive_abbrev
• Unification_recursive_abbrev of type_pairs

Relay variants (only raised inside catch arms for the dead exceptions above):

• typecore.Recursive_local_constraint
• typetexp.Variant_tags

bs_syntaxerr.ml:

• Conflict_bs_bs_this_bs_meth — no construction site anywhere

warnings.ml (14 constructors):

• Declared, never raised under compiler/: Comment_start (1), Comment_not_end (2), Method_override (7), Instance_variable_override (13), Illegal_backslash (14), Implicit_public_methods (15), Eol_in_string (29), Eliminated_optional_arguments (48), Bad_docstring (50), Bs_fragile_external (105), Bs_unimplemented_primitive (106)
• Always-false guard: Statement_type (10) — caller hard-codes statement = false; Unerasable_optional_argument (16) — disabled around its only check; Bs_uninterpreted_delimiters (108) — trigger AST rewritten by builtin PPX before the warning iterator runs

Warning numbers are kept as holes so existing user configs like -w "+a-1-2" keep working (parse_options silently ignores numbers no live constructor maps to).

Defensive unreachable — raise becomes assert false (* reason *)

Variant + reporter removed; raise site rewritten to match the established convention.

typecore.ml:

• Invalid_interval → assert false (* parser has no construction site for Ppat_interval *)
• Invalid_for_of_pattern → assert false (* parser's normalize_for_of_pattern replaces non-var patterns with Ppat_any *)
• Incoherent_label_order → collapsed into Apply_wrong_label with a comment (restoring has_label for an assert-false marker would mean re-introducing 3 helper functions just to flag one branch)

typetexp.ml:

• Unbound_type_constructor_2 → assert false (* parser rejects bare-Tvar Tconstr body shapes like type 'a t = 'a *)
• Ill_typed_functor_application, Apply_structure_as_functor → assert false (* both branches live behind Longident.Lapply, which the parser never constructs *)

typedecl.ml:

• Type_clash, Parameters_differ → assert false (* every recursive abbreviation hits Cycle_in_def first *)
• Null_arity_external → assert false (* Primitive.parse_declaration always assigns the magic prim_native_name encoding *)
• Bad_fixed_type → assert false (* is_fixed_type and expand_head agree on every parser-produced shape *)
• Varying_anonymous → assert false (* parser rejects \_` in type-parameter positions *)`
• Val_in_structure → assert false (* pval_prim = [] outside a signature only arises from parser external-recovery, post syntax error *)

bs_syntaxerr.ml:

• Unhandled_poly_type → assert false (* parser misreads inline 'a. as deprecated uncurried (. …) syntax *)

env.ml:

• Illegal_value_name → assert false on both guard branches (parser doesn't emit "->" or #-containing identifiers)

Variants restored to named-variant form

Three variants had already been restored during the original audit pass
(typedecl.Rebind_wrong_type via extension_rebind_mismatch.res,
typecore.Label_mismatch via label_mismatch_record_literal.res, and
typecore.Abstract_wrong_label via abstract_wrong_label.res).

Two additional variants restored in the same review pass — empirical
fixtures confirmed they fire on real ReScript source:

• typemod.With_cannot_remove_constrained_type — module type T = S with type t<'a> := 'a against S containing type t<'a> constraint 'a = int. Fixture: with_cannot_remove_constrained_type.res.
• bs_syntaxerr.Misplaced_label_syntax — labelled args passed via operator-identifier syntax: \"->"(x, ~b=...). Fixture: misplaced_label_syntax.res.

Three more typemod variants restored conservatively — I couldn't
construct a reproducing fixture, but couldn't conclusively prove
unreachability either, so they stay as named variants pending stronger
evidence:

• typemod.Cannot_eliminate_dependency (non-generative functor application paths)
• typemod.With_makes_applicative_functor_ill_typed (destructive substitution on applicative-functor signatures)
• typemod.Scoping_pack (first-class module packing with with type constraints)

What's left in the catalog

After this PR, ERROR_VARIANTS.md contains:

• ✓ — covered by at least one fixture.
• ☐ (needs <X> harness) — reachable but requires a CLI / binary / PPX / build harness, out of scope for super_errors{,_multi}.
• ? — three typemod variants where reachability couldn't be confirmed or denied with a fixture.

No ⚠ rows.

Validation

• rg confirmed no remaining references to truly-dead removed variants.
• 745 super_errors + 54 super_errors_multi fixtures pass; 925 stdlib mocha tests pass.
• make checkformat clean.
• Five fixtures added/restored across the audit: extension_rebind_mismatch.res, label_mismatch_record_literal.res, abstract_wrong_label.res, with_cannot_remove_constrained_type.res, misplaced_label_syntax.res.

[JonoPrest]

(see review below)

[JonoPrest]

Verification: sibling error fires first (S). Original raise site: typecore.ml:3894 in type_unknown_args's argument-label dispatch — fires when arity_ok && has_label l1 ty_fun (the label exists in the function type but at a different position). In modern uncurried ReScript, type_function (typecore.ml:3480–3488) eagerly unifies the function literal's arity-aware Tarrow with ty_expected_ via unify_exp_types, which raises Expr_type_clash before the wrong-position branch is reachable. Reproduction attempts — f(~b=1, ~a=2), cross-pipe label-flipping (apply_both(f, f) with mirrored call sites), partial application against fresh Tvars — all routed through Expr_type_clash. The dead-removal collapses the else raise Incoherent_label_order arm into Apply_wrong_label, which is the same diagnostic the sibling not (has_label l1 ty_fun) arm already raises.

[JonoPrest]

Verification: transitively dead (G). Only raised in unify_pat_types_gadt's Unification_recursive_abbrev → catch arm (typecore.ml:368, removed in the same commit). Unification_recursive_abbrev is itself only raised in Ctype.unify's Recursive_abbrev → catch arm (ctype.ml:2734). Ctype.Recursive_abbrev has zero raise sites under compiler/ — rg 'raise.*Recursive_abbrev' (excluding the unrelated live typedecl.Recursive_abbrev variant) returns nothing. Chain is dead end-to-end.

[JonoPrest]

Verification: parser blocks AST (P). Only raised when type_pat_aux sees Ppat_interval _. ReScript's parser (compiler/syntax/src/res_core.ml) has no construction site for Ppat_interval — interval patterns ('a' .. 'z') are OCaml syntax not part of the ReScript grammar. Fixture 'a' .. 'z' in a switch compiles silently (the parser sees a range expression, not an interval pattern). Replacement Location.raise_errorf keeps the original message for any PPX-forged AST.

[JonoPrest]

Verification: parser normalizes (P). Only raised in type_pat_aux for for ... in ... bindings whose pattern isn't a variable or _. ReScript's parser runs normalize_for_of_pattern (compiler/syntax/src/res_core.ml:3841) which catches every non-var, non-_ shape, emits a syntax error, and replaces the pattern with Ppat_any before the typer runs. Fixture for (a, b) in xs { ... } rejected at parse time with Did you forget a \"(\" here?. The named typer variant is dead behind the parser check; Location.raise_errorf preserves the message for any PPX-forged shape.

[JonoPrest]

Verification: parser blocks AST (P). Raised in transl_type_aux (typetexp.ml:472/617) when an inherited type's body expands to a bare Tvar — needs type 'a t = 'a plus a downstream inherit. ReScript syntax requires type parameters in angle brackets (type t<'a> = 'a); the parser rejects leading-'a form. Fixture type 'a t = 'a rejected as syntax error. The shape needed (bare-Tvar Tconstr body) is parser-unreachable; Location.raise_errorf covers any PPX-forged AST.

[JonoPrest]

Verification: no raise site (G). Declared but never raised. rg 'prerr_warning.*Eliminated_optional_arguments' returns zero matches under compiler/.

[JonoPrest]

Verification: no raise site (G). Declared but never raised. rg returns zero matches outside warnings.ml. Also default-disabled in bsc_warnings.ml.

[JonoPrest]

Verification: no raise site (G). Declared but never raised. rg returns zero matches outside warnings.ml.

[JonoPrest]

Verification: no raise site (G). Declared but never raised. rg returns zero matches outside warnings.ml.

[JonoPrest]

Verification: PPX rewrites the trigger AST (S). Raised at bs_warnings.ml:29 for Pconst_string (_, Some "js"). The parser does emit Some "js" for all strings in ParseForTypeChecker mode (res_core.ml:1066), but the builtin PPX runs first: Bs_builtin_ppx.mapper calls Ast_utf8_string_interp.transform_exp which replaces Some "js" with Some "j" (escaped) or Some "*j" (backtick) before Bs_ast_invariant.check_constant ever sees the constant. With -bs-no-builtin-ppx, the warning iterator is skipped entirely (ppx_entry.ml:58–62). Either way the warning never fires for a real ReScript source program.

[JonoPrest]

(superseded — see other reviews for full validation)

[JonoPrest]

Inline validation comments — for each removed item, the verification method and concrete evidence. Categories: G grepped dead (no raise site under compiler/), P parser blocks the required AST, S sibling error fires before this one, R reachable but the post-removal Location.raise_errorf emits the same user-facing message. Two variants are marked R — they're still safe to remove, but the original audit's "unreachable" framing was too strong.

[JonoPrest]

Update (commit 4c8c646)

Reworked per review feedback. Two principled changes:

1. Defensive unreachable raise sites now use assert false (* reason *) instead of Location.raise_errorf — matching the established typer-module convention (57 existing assert false uses in typecore/typedecl/typemod/typetexp; zero Location.raise_errorf calls in those four modules in master). The earlier approach moved code rather than removing it and introduced a foreign pattern.

2. Five variants restored to named-variant form:

• typemod.With_cannot_remove_constrained_type — confirmed reachable (module type T = S with type t<'a> := 'a with constrained S). New fixture: with_cannot_remove_constrained_type.res.
• bs_syntaxerr.Misplaced_label_syntax — confirmed reachable (\"->"(x, ~b=...)). New fixture: misplaced_label_syntax.res.
• typemod.Cannot_eliminate_dependency, typemod.With_makes_applicative_functor_ill_typed, typemod.Scoping_pack — couldn't reproduce, retained conservatively as named variants with ? status in the catalog rather than removed.

Inline comments above: the 14 still-anchored variant-removal comments correctly identify each variant as unreachable. The replacement-mechanism notes in them say Location.raise_errorf — that has now been switched to assert false (* reason *) (same justification, different syntax). The 5 comments for now-restored variants have been deleted.

Net diff: 22 named error variants removed (down from the original 24) + 3 supporting Ctype exceptions + 1 helper (has_label) + 14 warning constructors. 545 deletions / 328 additions across 29 files.