feat(grammar): qualified Type::Variant patterns in match arms (Refs #122)

`pattern_primary` accepted only bare `upper_ident` / `upper_ident(p..)`
constructors, never the qualified `Type::Variant` form. So every
qualified match arm was a parse error — `match c { Color::Red => .. }`,
recursive ADTs (`IntList::Cons(h, t) => ..`), and stdlib/traits.affine's
`Ordering::Less => ..`. This blocked both `= match {..};` expression
bodies and block-body matches.

Add `upper_ident COLONCOLON upper_ident` and the payload form to
pattern_primary. The type qualifier is discarded — PatCon carries only
the variant name, exactly matching ExprVariant and the codegen tag
dispatch (`scrut.tag === "Variant"`, payload at `.values[i]`), so the
qualified and bare forms are interchangeable and consistent with the
enum factory emission.

Regression: tests/codegen-deno/match_enum.{affine,harness.mjs} —
nullary qualified patterns in an expression-body match, plus recursive
`len`/`sum` over a payload ADT (verified len=3, sum=60). `dune runtest`
unchanged (same 2 pre-existing E2E Node-CJS vscode failures, 214 tests,
zero new regressions). Deno-ESM suite green.

Refs #122.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

lib/parser.mly

@@ -918,6 +918,17 @@ pattern_primary:
   | name = upper_ident { PatCon (mk_ident name $startpos $endpos, []) }
   | name = upper_ident LPAREN pats = separated_list(COMMA, pattern) RPAREN
     { PatCon (mk_ident name $startpos(name) $endpos(name), pats) }
+  /* Qualified variant patterns `Type::Variant` / `Type::Variant(p, ..)`
+     (issue #122 v2). The type qualifier is discarded — PatCon carries
+     only the variant name, matching ExprVariant and the codegen tag
+     dispatch (`scrut.tag === "Variant"`). Without these, `match c {
+     Color::Red => .. }` (and stdlib/traits.affine's `Ordering::Less`)
+     was a parse error. */
+  | _ty = upper_ident COLONCOLON name = upper_ident
+    { PatCon (mk_ident name $startpos(name) $endpos(name), []) }
+  | _ty = upper_ident COLONCOLON name = upper_ident
+    LPAREN pats = separated_list(COMMA, pattern) RPAREN
+    { PatCon (mk_ident name $startpos(name) $endpos(name), pats) }
   | LPAREN RPAREN { PatTuple [] }
   | LPAREN p = pattern RPAREN { p }
   | LPAREN p = pattern COMMA ps = separated_nonempty_list(COMMA, pattern) RPAREN

tests/codegen-deno/match_enum.affine

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.4 regression: qualified `Type::Variant` patterns in
+// match arms (nullary + payload), as both `= match {..};` expression
+// bodies and recursive functions. Previously a parse error
+// (pattern_primary had no `Type::Variant` production).
+
+pub enum Color { Red, Green, Blue }
+
+pub fn rank(c: Color) -> Int = match c {
+  Color::Red => 1,
+  Color::Green => 2,
+  Color::Blue => 3
+};
+
+pub enum IntList { Nil, Cons(Int, IntList) }
+
+pub fn len(xs: IntList) -> Int {
+  match xs {
+    IntList::Nil => 0,
+    IntList::Cons(h, t) => 1 + len(t)
+  }
+}
+
+pub fn sum(xs: IntList) -> Int {
+  match xs {
+    IntList::Nil => 0,
+    IntList::Cons(h, t) => h + sum(t)
+  }
+}
+
+// Construction uses the bare enum-factory names (Nil / Cons) emitted by
+// the enum codegen; qualified `Type::Variant` is exercised in the match
+// patterns above (the v2.4 feature under test).
+pub fn demo_list() -> IntList = Cons(10, Cons(20, Cons(30, Nil)));

tests/codegen-deno/match_enum.harness.mjs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// issue #122 v2.4 — qualified Type::Variant patterns + recursive ADTs.
+import assert from "node:assert/strict";
+import { rank, Red, Blue, len, sum, demo_list } from "./match_enum.deno.js";
+
+assert.equal(rank(Red), 1, "match expr-body, nullary qualified pattern");
+assert.equal(rank(Blue), 3, "match expr-body, last arm");
+
+const xs = demo_list(); // Cons(10, Cons(20, Cons(30, Nil)))
+assert.equal(len(xs), 3, "recursive len over ADT, payload pattern");
+assert.equal(sum(xs), 60, "recursive sum binds payload (h, t)");
+
+console.log("match_enum.harness.mjs OK");