feat(dsl): repeat+N syntax for at-least-N iterations

Extends the existing `repeat+` shorthand (min=1, one-or-more) to
accept an arbitrary minimum count: `repeat+2 <X>` requires at least
2 iterations, `repeat+5 <X>` at least 5, etc. The engine already
supported any `Node.min` value (it's a `uint32_t`); only the DSL
surface gated higher counts behind hand-writing the JSON form.

**Use cases**:

* Binary operators that need exactly two operands (and would currently
  reach for a `Choice` between "multi" and "single" forms or an awkward
  initial-operand + `repeat`-tail dance):

      OP: sequence dict {
        repeat+2 <OPERAND>:args[]=@ separator <OP_TOK>:op=@
      }

  Wrapping the variadic form in `repeat+2` says "≥2 args required" in
  one quantifier rather than spreading it across multiple rules.

* EDA spec cardinalities — `PIN` needs ≥1 ports, `MACRO` needs ≥0
  pins, `NET` may require ≥2 ROUTED segments, etc. `repeat+1` (= the
  existing `repeat+`) and `repeat+2` cover the common cases.

**Surface forms**:

  repeat <X>       → min=0  (zero-or-more, classic PEG `*`)
  repeat+ <X>      → min=1  (one-or-more, classic PEG `+`)
  repeat+N <X>     → min=N  (at-least-N; N ≥ 2)

`repeat+` is shorthand for `repeat+1`. Save canonicalises to the
shortest form: min=0 → `repeat`, min=1 → `repeat+`, min=N≥2 →
`repeat+N`. Round-trip stable.

**Meta-grammar change**:

The `REPEAT_EXPR` rule's optional `?"+":min=1` becomes an optional
Choice between two alternatives:

  REPEAT_PLUS_FORM: choice {
    <REPEAT_PLUS_N>,    // "+N" — emits min from int
    <REPEAT_PLUS_ONE>   // "+" alone — emits min=1
  }

  REPEAT_PLUS_N: sequence { "+", int:min=@ }
  REPEAT_PLUS_ONE: sequence { "+":min=1 }

`REPEAT_PLUS_N` first in source order so `+2` greedy-matches the
digit; `REPEAT_PLUS_ONE` is the fallback for bare `+` via Choice-frame
alt-failure recovery. Save dispatch picks `REPEAT_PLUS_ONE` for
dict.min == 1 (Value-const discriminator matches) and falls to
`REPEAT_PLUS_N` for higher values.

**Trade-off — informational lint warning on the meta-grammar**:

Adding the Choice introduces an LL(k) shared-prefix pattern (both
alts start with `"+"`). The lint correctly flags it as informational
since the previous `ddb274f` commit made the LL(k) warning
unsilenceable. Updated the "bundled .rawast grammar is clean" test to
allow informational warnings on this specific rule (`REPEAT_PLUS_FORM`)
— same shape as the FastDRC constraint grammar pattern that motivated
the lint clarification. Any *other* lint issue on the rawast grammar
still fails the test.

**Verification**:

End-to-end test (`/tmp/test_repeat_n.rawast` with `repeat+2 int:nums[]=@`):

  parse "1, 2"     → {nums: [1, 2]}      ✓
  parse "1, 2, 3"  → {nums: [1, 2, 3]}   ✓
  parse "1"        → error (min=2 not met) ✓

Round-trip via meta-grammar:

  source: `repeat+2 int:nums[]=@ separator ","`
  parsed dict: {min: 2, type: "repeat", value: ..., separator: ...}
  saved DSL:  `repeat+2 <int>:nums[]=@ separator ","`  ✓

All shipped grammars (json, rawast, gdsii, lefdef, tcl) still load
cleanly. 216/216 C++ doctest + 47/47 Python pytest passing.

**Docs**:

* `docs/rawast-format.md` §4.8 — updated quantifier section with the
  new surface form, examples for min=0/1/2/5 cases, and explicit
  round-trip canonicalisation note.

Author: lanserge

docs/rawast-format.md

@@ -762,20 +762,37 @@ cost is real, even if small), not bugs. There is no flag to suppress
 them; either restructure the alternatives to diverge earlier, or
 accept the warning as a permanent design note.
 
-### 4.8 Repeat — `repeat expression [separator expression]`
+### 4.8 Repeat — `repeat[+[N]] expression [separator expression]`
 
 ```
-repeat_expr ::= 'repeat' expression ('separator' expression)?
+repeat_expr ::= 'repeat' ('+' int?)? expression ('separator' expression)?
 ```
 
-Zero-or-more iteration of the given expression, optionally separated
-between iterations by the separator expression. Produces no container
-of its own; the surrounding sequence's container catches the iteration
+Iteration of the given expression, optionally separated between
+iterations by the separator expression. Produces no container of its
+own; the surrounding sequence's container catches the iteration
 results.
 
+The quantifier suffix sets a minimum required iteration count:
+
+```
+repeat <X>          // min=0 (zero-or-more)
+repeat+ <X>         // min=1 (one-or-more)
+repeat+2 <X>        // min=2 (at-least-two)
+repeat+5 <X>        // min=5 (at-least-five), etc.
+```
+
+`repeat+` is shorthand for `repeat+1`. The save direction canonicalises
+back to the same surface form on round-trip (min=1 emits `repeat+`,
+min=N for N≥2 emits `repeat+N`).
+
+Examples:
+
 ```
-repeat <VALUE> separator ","            // for arrays
-repeat <PAIR> separator ","             // for dicts
+repeat <VALUE> separator ","            // 0+ values, for arrays
+repeat <PAIR> separator ","             // 0+ pairs, for dicts
+repeat+ <ITEM>                          // 1+ items (classic PEG `+`)
+repeat+2 <ARG>:args[]=@ separator ","   // at least 2 args (e.g. a binary op)
 ```
 
 ### 4.9 Optional — `?expression`

grammars/rawast.json

@@ -321,35 +321,47 @@
         "type": "key",
         "key": "repeat",
         "bindings": [
-          {
-            "name": "type",
-            "value": "repeat"
-          }
+          { "name": "type", "value": "repeat" }
         ]
       },
+      { "type": "REPEAT_PLUS_FORM", "optional": true },
       {
-        "type": "key",
-        "key": "+",
-        "optional": true,
+        "type": "ITEM",
         "bindings": [
-          {
-            "name": "min",
-            "value": 1
-          }
+          { "name": "value", "value": "@" }
         ]
       },
+      { "type": "SEPARATOR", "optional": true }
+    ]
+  },
+  "REPEAT_PLUS_FORM": {
+    "type": "choice",
+    "value": [
+      { "type": "REPEAT_PLUS_N" },
+      { "type": "REPEAT_PLUS_ONE" }
+    ]
+  },
+  "REPEAT_PLUS_N": {
+    "type": "sequence",
+    "value": [
+      { "type": "key", "key": "+" },
       {
-        "type": "ITEM",
+        "type": "int",
         "bindings": [
-          {
-            "name": "value",
-            "value": "@"
-          }
+          { "name": "min", "value": "@" }
         ]
-      },
+      }
+    ]
+  },
+  "REPEAT_PLUS_ONE": {
+    "type": "sequence",
+    "value": [
       {
-        "type": "SEPARATOR",
-        "optional": true
+        "type": "key",
+        "key": "+",
+        "bindings": [
+          { "name": "min", "value": 1 }
+        ]
       }
     ]
   },

grammars/rawast.rawast

@@ -111,13 +111,32 @@ CHOICE_EXPR: sequence {
   "{", <ITEMS>:value=@, "}"
 }
 
+// `repeat` quantifier syntax:
+//   repeat <X>       → min=0 (zero-or-more, classic PEG `*`)
+//   repeat+ <X>      → min=1 (one-or-more, classic PEG `+`)
+//   repeat+N <X>     → min=N (at least N occurrences, N ≥ 2)
+//
+// The two `+`-prefixed forms are a Choice. Save dispatch picks
+// `REPEAT_PLUS_ONE` for dict.min == 1 (specific const matches) and
+// falls through to `REPEAT_PLUS_N` for higher values. Parse tries
+// `REPEAT_PLUS_N` first so `+2` greedy-matches the digit; the engine
+// falls back to `REPEAT_PLUS_ONE` for bare `+` via Choice-frame
+// alt-failure recovery.
 REPEAT_EXPR: sequence {
   "repeat":type="repeat",
-  ?"+":min=1,
+  ?<REPEAT_PLUS_FORM>,
   <ITEM>:value=@,
   ?<SEPARATOR>
 }
 
+REPEAT_PLUS_FORM: choice {
+  <REPEAT_PLUS_N>,
+  <REPEAT_PLUS_ONE>
+}
+
+REPEAT_PLUS_N: sequence { "+", int:min=@ }
+REPEAT_PLUS_ONE: sequence { "+":min=1 }
+
 SEPARATOR: sequence { "separator", <ITEM>:separator=@ }
 
 // Key literal. Two surface forms with distinct `type` values so save

tests/test_linter.cpp

@@ -5,6 +5,8 @@
 #include <rawast/parsers.hpp>
 
 #include <memory>
+#include <set>
+#include <string>
 
 using namespace rawast;
 
@@ -359,7 +361,14 @@ TEST_CASE("Linter: the bundled JSON grammar is clean") {
     CHECK(issues.empty());
 }
 
-TEST_CASE("Linter: the bundled .rawast grammar is clean") {
+TEST_CASE("Linter: the bundled .rawast grammar has only intentional informational warnings") {
+    // The meta-grammar uses intentional shared-prefix Choices in a few
+    // places (KEY_EXPR's normal vs strict variants, REPEAT_PLUS_FORM's
+    // +N vs + variants) — these trigger LL(k) informational warnings
+    // but parse and round-trip correctly. The test allows informational
+    // warnings on those specific Choice rules; any OTHER lint output
+    // (prefix-collision, wildcard-Choice-type-emit, raw-consume misuse,
+    // or LL(k) warnings on unexpected rules) still fails the test.
     Grammar g;
     g.register_parser(std::make_unique<DoubleQuoteStringParser>());
     g.register_parser(std::make_unique<IdentifierParser>());
@@ -371,9 +380,25 @@ TEST_CASE("Linter: the bundled .rawast grammar is clean") {
     g.add_ignore("block_comment");
     REQUIRE(load_json_grammar_from_file(g, "grammars/rawast.json"));
 
+    // Allow informational LL(k) warnings on these specific rules
+    // (the grammar uses intentional shared-prefix Choices here).
+    const std::set<std::string> allowed_informational = {
+        "REPEAT_PLUS_FORM",
+    };
+
     auto issues = lint_grammar(g);
-    if (!issues.empty()) {
-        FAIL("Unexpected lint issue in .rawast grammar: " << issues[0].description);
+    for (const auto& issue : issues) {
+        // Informational warnings on allowed rules are fine.
+        if (issue.description.find("informational [") != std::string::npos) {
+            bool is_allowed = false;
+            for (const auto& rule : allowed_informational) {
+                if (issue.description.find("[" + rule + "]") != std::string::npos) {
+                    is_allowed = true;
+                    break;
+                }
+            }
+            if (is_allowed) continue;
+        }
+        FAIL("Unexpected lint issue in .rawast grammar: " << issue.description);
     }
-    CHECK(issues.empty());
 }