fix(codegen): emit label accessors nested in groups and mixed same-rule labels

[tinovyatkin]

Fixes #201. Closes #233.

What the issue asked for vs. what was actually broken

The issue's two headline examples already worked at HEAD — PR #211 landed both
primitiveType.typeName() and messageDeclaration.name(). Checking the real
Idl.g4 before writing any code is what found the actual gap: 20 labels across
12 rules get no accessor, and neither of the issue's proposed fixes addresses
them, because the defects are in the structural ref model
(collect_structural_context_refs_with_cardinality), not in the accessor
derivation (context_label_accessor) the issue points at.

Cause 1 — group collapse swallowed labels sitting inside the block

A token-only block collapses into a single group ref. That collapse is what makes
x=(A | B) yield one labeled token child, so it has to stay. But it also fired
when the block was unlabeled and the labels sat inside it:

messageDeclaration: (doc=DocComment)? ... (oneway=Oneway | Throws errors+=identifier ...)? ;

Here the collapse produced one ref carrying the block's label (None) and
continued — never descending, so doc, oneway and errors were simply
dropped. Collapse now requires the label to be on the group itself; otherwise we
descend and let the inner refs carry their own labels.

Cause 2 — stable_accessor was masking a dishonest cardinality

Refs inside a multi-alternative block were blanket-marked stable_accessor: false
while still carrying min: 1 — i.e. the model claimed a child is always present
when only the taken branch supplies it. The flag papered over the lie instead of
correcting it.

Branch refs now report min: 0. That makes a sibling alternative matching the
same target read as inexact, so the pre-existing occurrence-lookup guards
(exact_target_cardinality) reject exactly the layouts where positional access
could resolve to another branch's child — no new guard logic needed. This is what
lets name=identifier and errors+=identifier coexist on one rule:

pub fn name(&self)   -> Result<IdentifierContext<'a>, MissingChildError> { ... .nth(0) ... }
pub fn errors(&self) -> impl Iterator<Item = IdentifierContext<'a>> + '_  { ... .skip(1) ... }

Follow-ups from review — the same honesty applied to action translation

Making branch refs inexact exposed a latent flaw one layer over, in
TranslationCtx::resolve_label. That function derives a positional CST index by
counting same-target refs ahead of a label, and several shapes make that count
meaningless. ~50 reviewer findings across ~25 rounds (Codex and CodeRabbit),
each verified against the parent commit to separate regressions this PR
introduced from pre-existing gaps it exposed:

Shape	Before	Regression?	Now
r : (B | x=B) {$x}	nth(1) on a 1-child CST	yes	errors loudly
r : ((x=A))? EOF	no x() accessor	no	x() emitted
r : (A | B)? x=(C | D) {$x}	cannot translate $x	yes	generates again
r : ({false}? x=A)? A {$x}	nth(0) reads the mandatory A	yes	errors loudly
r : errors+=u name=u {$name}	nth(0) reads an errors child	yes	nth(1)
r : errors+=u+ name=u {$name}	wrong nth(), silently	no	errors loudly
r : name=e ... errors+=e {$errors}	read folds in name's child	no	errors loudly
r : (x=A | x=B) {$x}	searches for A on the B branch	yes	errors loudly
r : x=A | x=B + @after {$x}	A lookup, defaults on B	no	errors loudly
r : (xs+=(A | B))+ {$xs}	.last()…collect() — does not compile	yes	errors loudly
r : (x=A)+ {$x}	nth(0) pins the first, not the latest	yes	errors loudly
r : (x=A {$x} B | A C)	cannot translate $x	yes	translates again
r : x=(A | B) | x=(C | D) + @after	cannot translate $x	yes	translates again
r : x=A | A + @after {$x}	reads the unlabeled A	no	errors loudly
r : xs+=A xs+=B {$xs}	iterates A, drops every B	no	errors loudly
r : ({false}? x=A)? A? {$x}	reads the follower's token as x	yes	errors loudly
r : ((x=e {$x} | f) | e)	cannot translate $x	yes	translates again
r @after {$x} : (x=A | A) EOF	reads the sibling branch's A	yes	errors loudly
r : (xs+=A)? 'a' {$xs} (A : 'a';)	iterates the literal as xs	yes	errors loudly
r : xs+=A {$xs} A;	cannot translate $xs	yes	translates again
r : (x=A e {$x} | x=A f {$x})	cannot translate $x	yes	translates again
r @after {$x} : x=A | x='a';	cannot translate $x	yes	translates again
r : (x=A | A) {$x} EOF;	reads the sibling branch's A	yes	errors loudly
r : (a=A | b=A) x=A EOF;	x() accessor dropped	yes	x() emitted
r : (A | B) x=A {$x}	reads the group's token	no	errors loudly
r : (e | xs+=e {$xs}) EOF;	cannot translate $xs	yes	translates again
r : ((x=(A | B))) A {$x}	last() reads the trailing A	no	reads nth(0)
t=~'x' 'z' {$t.text} on yz	last() reads z	no	reads y
r : (A | xs+=A) {$xs} EOF;	reports the sibling's token	yes	errors loudly
r @init {$xs} : xs+=A A;	cannot translate $xs	yes	translates again
((a=A | b=B) C | D) x=(E | F) {$x}	nth(2), wrong on D E	yes	falls back to last()
r @after {$x} : (x='a') | B;	reports b as x	yes	errors loudly
r : (x=A | x=B) EOF;	x() dropped	yes	x() emitted (merged read)
r : (A x=A | B) EOF;	x() dropped	yes	x() emitted
r : (A x=A {$x} | B) EOF;	cannot translate $x	yes	translates again
r : (a=A | ) x=A EOF;	x() at nth(1), misses empty branch	yes	x() dropped
r @after {$x} : A x=A | (A B? | A C?);	cannot translate $x	yes	translates again
r @after {$x} : (B) x=A | x='a';	mixed-mode merge on a false leading flag	yes	errors loudly
r : ({false}? x=A | A) (B {$x} | C)	sibling exempted by an unrelated choice	yes	errors loudly
r : D A x=(B | C) {$x} on dxab	recovery shifts the index, reads x	yes	reads b
r : ((A B)+ x=A)? EOF;	x() at nth(1), ignores the closed +	yes	x() dropped
r : ((q | q | b) x=q | c) EOF;	inner arity read as the outer's	yes	x() dropped
r : (A | x=A) {$x}	reads the preceding sibling branch	yes	errors loudly
r : (B y=C? | ) x=A | x='a';	expanded block reported no terminal	yes	errors loudly
r @after {$xs…collect()} : xs+=A | xs+='a';	.collect() on a String — does not compile	yes	errors loudly
r @after {$xs…collect()} : xs+='a' | B xs+='a';	same broken .collect()	no	errors loudly
(((y=A | z=A | B) x=A {$x}) | C)	nth(0)/nth(1), wrong on ba	no	errors loudly

The unifying fix is that resolve_label now carries the running occurrence as
Option<usize> and stops guessing when the position isn't fixed:

• refs with inexact cardinality poison the bucket — that covers both
  mutually-exclusive branch refs and unbounded list runs, without special-casing
  either;
• empty-target refs (token groups, wildcards) stay out of the buckets
  entirely, since their reads take the last terminal child and never consult an
  index — sharing one "" bucket was what made unrelated groups interfere;
• optional labels are rejected when a following same-target child can
  coexist with them and slide into their position. Cardinality cannot express
  this: a sequential optional follower may consume the label's only token, while a
  sibling-branch ref reports the same min: 0 yet never coexists. ElementRef
  therefore carries choice_branch: (choice id, branch index), so
  can_coexist_with answers it structurally instead of by inference. The tag is
  the full choice ancestry, and the exclusion applies only to mid-rule bodies —
  an @after body runs whichever branch the parse took, so a sibling match really
  can be the child present when its read executes;
• the action's enclosing branch comes from choice_spans — the byte extent of
  each enclosing choice block — because ref order cannot distinguish an action
  after a group from one inside its last branch;
• @init runs before any child exists, so no child-based hazard applies;
• child counting is one shared routine (exact_child_count) that folds nested
  choices innermost-first and takes an explicit restricted_to_one_path flag —
  filtering to a path and demanding cross-branch agreement are contradictory;
• token-backed comparisons overlap token_types rather than matching source
  spelling, since the read queries by type (A : 'a'; makes A and 'a' one
  child) — the same rule the typed-accessor path already uses;
• reads the translator cannot express (a list over a token group has no target
  to iterate; a repeated single label has no last-occurrence read) stay unresolved
  instead of falling through to a different read — one of them was emitting Rust
  that does not compile.

Roughly a third end up better than the parent commit rather than merely
restored — the unbounded-list, list-sharing-a-target, nested-grouping,
inner-choice-arity, and literal-list cases were already wrong before this PR, the
last of which generated Rust that does not compile.

Two further structural changes came out of the later rounds and are worth calling
out, because both replace a per-call-site convention with an enforced one:

• ElementRef::retain_choices — choice_branch, choice_arity,
  choice_spans, and branch_spans are indexed by position, so dropping a choice
  must drop the same position from all four. Three call sites instead retained
  one and truncated the rest, which is equivalent only when the dropped entries
  form a suffix — and since ancestry is outermost-first while the dropped
  choices are the outer ones, it was wrong in the common case. The invariant now
  lives in one method.
• ParserRuleContext::labeled_terminal_children (new public runtime API) — a
  grammar-derived index knows nothing about error recovery. A deleted token
  occupies a child slot but corresponds to no grammar element, so counting it
  shifts every later position; an inserted token is the value ANTLR binds to the
  label and must stay. The new iterator keeps inserted and skips deleted,
  discriminating on the synthetic -1:-1 span — the same rule fix(codegen): keep token labels stable through recovery #235's generated
  __labeled_token_children accessors already apply, so the two label surfaces
  now agree.

Correction: the block-label case is fixed, and #233 is closed

An earlier revision of this description said a block label reading across an
intervening terminal was unfixable here, because deciding it needed element spans
that ElementRef did not carry. That was wrong.
grammar::model::Element has carried span: SourceSpan all along — it was simply
never propagated into embedded::ElementRef. Once threaded through, the action's
byte offset makes every remaining question in this area decidable, and the guesses
that stood in for it stopped trading one correct case for another.

The block-label read is now positional: terminal_children().nth(i) where i
is the number of terminals matched ahead of the block on the action's parse path.
last() survives only as the fallback when that count is not fixed. So
((x=(A | B))) C {$x} reads the token the label bound, and
t=~'x' 'z' {$t.text} still works — the two are distinguished rather than traded.

Worth noting how invisible the original bug was: the upstream descriptors use
input zz, so both tokens are z and last() passed by luck. I confirmed it
with a : t=~'x' 'z' {$t.text} on input yz — the action printed z before
and prints y now.

Closes #233.

Design note: I did not take the issue's suggested approach

The issue floated "recording label ids on children in the tree, or deriving from
the alternative's shape at codegen." Recording label ids would grow every
node. Making the cardinality honest instead let the existing guards do the work:
both new shapes resolve with zero runtime cost and zero new tree state.

Verification

Check	Result
Accessor-set diff vs. parent commit — Avro IDL	+20 gained, 0 lost
Accessor-set diff vs. parent commit — Kotlin (151 contexts)	byte-identical
antlr4-runtime-testsuite conformance sweep	357 / 357
Unit tests / CLI integration tests	780 / 38 pass
Kotlin parity (vs. antlr4-python3-runtime oracle)	9 / 9 trees identical
JavaScript / TypeScript parity	6 / 6 and 5 / 5 identical
cargo clippy --locked --all-targets --all-features -- -D warnings	clean

The accessor-set diff is the check I'd weight most. I built the generator at the
parent commit in a scratch git worktree, generated the same grammars with both
binaries, and diffed the emitted pub fn set per context — proving nothing was
lost matters more than counting what was gained. Presence alone is not
evidence of correctness. Both figures were re-confirmed after every commit — 24 of them.

The 357/357 sweep also does real work for the resolve_label guard: it exercises
hundreds of embedded actions, so it demonstrates the guard rejects no legitimate
translation.

I also confirmed the new end-to-end tests actually execute: the generated-project
tests run under cargo test inside a temp crate, so I temporarily broke one
assertion and watched it fail. Without that they could have compiled-but-skipped
and looked green.

Two things that looked like bugs but are correct

• doc reads None on the unmodified Idl.g4. DocComment is
  -> channel(HIDDEN), so it never becomes a CST child — None is correct ANTLR
  behaviour. Verified against a de-hidden copy of the grammar, where doc reads
  Some("/** hello doc */").
• mixed_unbounded (unary* IN errors+=unary) still declines. A variable
  count of the label's own target ahead of it leaves no fixed .skip(N). Pinned
  as an explicit negative test so a future change can't silently start emitting an
  unsound accessor here.

Tests added

Extended tests/fixtures/antlr4-rust-gen/multi-alternative-label/T.g4 with both
issue shapes plus five hazard shapes, and covered them at three levels:

• Generator snapshots pin the complete generated surface of all six contexts —
  grouped and mixed (fixed shapes), nested_group (label under redundant
  grouping), and the three declines mixed_unbounded, branch_hazard, and
  branch_rival. The declines are snapshotted whole rather than probed with
  !contains, per the AGENTS.md guidance; reviewing the recorded output is how I
  confirmed they drop only the label accessor and keep the plain
  unary_children() / num_token() surface.
• Runtime tests (tests/antlr4_rust_gen_cli.rs) parse real input through the
  generated parser and assert the label reads agree with the text — including both
  branches of the choice and the all-optionals-absent case.
• Action-translation unit tests pin each resolve_label hazard separately,
  one per shape in the table above, including
  list_refs_ahead_of_a_single_label_are_counted_then_poison_when_unbounded
  (covering both the countable and the unbounded ordering).
• A label-resolution corpus (tests/fixtures/antlr4-rust-gen/label-resolution/,
  47 grammars) pins every outcome with its reason, as
  (fixture, label, resolves, why) rows in
  label_resolution_corpus_matches_expected_outcomes. This is the artefact I'd
  point a future maintainer at: it makes each decline a documented decision rather
  than an absence, and it caught two of my own over-corrections during the later
  rounds. I mutation-tested it by reverting one fix and confirming it named the
  case.

New rules and tokens are appended after the existing ones deliberately: adding
them mid-file renumbers rule/token indices and churns every pre-existing context
snapshot. That ordering keeps the snapshot diff to the two genuinely new files.

Reviewer notes

• src/bin/antlr4-rust-gen.rs is the core change: ~15 lines in the block arm of
  collect_structural_context_refs_with_cardinality, plus the new
  structural_block_labels_inside helper. src/bin_support/embedded.rs carries the
  resolve_label guard. The rest of the diff is tests, fixture, and snapshots.
• Copy/Paste Detection reports 2 duplications — both are pre-existing test code
  at lines 1507/1607 and 2589/2656 of tests/antlr4_rust_gen_cli.rs, well outside
  this diff's 653–770 range. The bot scans whole changed files, so they surface here
  without being introduced here.
• C# grammar generation fails at both the parent commit and this one —
  pre-existing and unrelated, so I left it out of scope rather than widening the PR.
• One declined finding, stated rather than quietly skipped: CodeRabbit asked
  that unlabeled ElementKind::Range elements be accounted for in
  alt_can_satisfy_read. Its repro (r : x=(A | B) | 'c'..'d';) is rejected by
  validation before reaching the resolver (error[G4S009]), matching ANTLR's own
  error(181): token ranges not allowed in parser. There is no reachable input
  that needs the guard.
• A process correction I owe the record: for two rounds I reported "no open
  findings" when there were several. My checker fetched only the first page of
  review comments and filtered to one bot. Both bugs are fixed; the current script
  paginates and covers every bot, and reports 0 unreplied across all 96 threads.

[github-actions]

Copy/Paste Detection

Found 11 duplication(s) across 4 changed Rust file(s) (threshold: 100 tokens).

Show duplications

Found a 26 line (160 tokens) duplication in the following files:

• Starting at line 732 of src/bin_support/embedded.rs
• Starting at line 823 of src/bin_support/embedded.rs

                    };
                }
            }
        }
        // Deepest choices first, so an inner result rolls up into its parent branch.
        // The list is rebuilt from `per_branch` each pass, because folding an inner
        // choice *creates* an entry for its parent that must then fold in turn.
        let mut processed: BTreeSet<usize> = BTreeSet::new();
        // Deepest unprocessed choice still holding entries. Folding one creates an
        // entry for its parent, so the candidate set is re-examined every pass.
        while let Some(choice) = per_branch
            .keys()
            .map(|(choice, _)| *choice)
            .filter(|choice| !processed.contains(choice))
            .max_by_key(|choice| depth_of_choice.get(choice).copied().unwrap_or(0))
        {
            processed.insert(choice);
            let counts = per_branch
                .iter()
                .filter(|((candidate, _), _)| *candidate == choice)
                .map(|((_, branch), count)| (*branch, *count))
                .collect::<Vec<_>>();
            if counts.is_empty() {
                continue;
            }
            let agreed = if restricted_to_one_path {
```rust

---

Found a 23 line (148 tokens) duplication in the following files:
* Starting at line 2675 of src/bin_support/embedded.rs
* Starting at line 3282 of src/bin_support/embedded.rs

```rust
    fn unscoped_reads_reject_alternatives_that_would_satisfy_them_unbound() {
        let token_ref = |label: Option<&str>, target: &str, token_type| ElementRef {
            label: label.map(ToOwned::to_owned),
            target: target.to_owned(),
            token_types: vec![token_type],
            is_block: false,
            is_list: false,
            cardinality: ChildCardinality {
                min: 1,
                max: Some(1),
            },
            stable_accessor: true,
            choice_branch: Vec::new(),
            choice_arity: Vec::new(),
            choice_spans: Vec::new(),
            group_spans: Vec::new(),
            branch_spans: Vec::new(),
            leading_terminal: true,
            span: None,
            branch_local_cardinality: ChildCardinality::ONE,
            group_local_cardinality: ChildCardinality::ONE,
        };
        let translate = |second: ElementRef| {

---

Found a 22 line (132 tokens) duplication in the following files:

• Starting at line 1882 of tests/antlr4_rust_gen_cli.rs
• Starting at line 1982 of tests/antlr4_rust_gen_cli.rs

        "parser grammar Delegate;\ndelegated: {isTypeName()}? ID;\n",
    )
    .expect("delegate grammar should be writable");
    fs::write(&tokens, "lexer grammar Tokens;\nID: [a-z]+;\n")
        .expect("token grammar should be writable");

    let output = run_antlr4_rust_gen(&[
        root.as_os_str(),
        tokens.as_os_str(),
        OsStr::new("-I"),
        temp.path().as_os_str(),
        OsStr::new("--out-dir"),
        out.as_os_str(),
    ]);
    assert!(
        output.status.success(),
        "stdout: {}\nstderr: {}",
        utf8(&output.stdout),
        utf8(&output.stderr)
    );
    let parser = fs::read_to_string(out.join("root.rs")).expect("parser should be emitted");
    assert!(parser.contains("pub trait RootHooks"), "{parser}");
```rust

---

Found a 22 line (121 tokens) duplication in the following files:
* Starting at line 2472 of src/bin_support/embedded.rs
* Starting at line 2624 of src/bin_support/embedded.rs

```rust
            is_list,
            cardinality: ChildCardinality {
                min: 1,
                max: Some(1),
            },
            stable_accessor: true,
            choice_branch: Vec::new(),
            choice_arity: Vec::new(),
            choice_spans: Vec::new(),
            group_spans: Vec::new(),
            branch_spans: Vec::new(),
            leading_terminal: true,
            span: Some(span),
            branch_local_cardinality: ChildCardinality::ONE,
            group_local_cardinality: ChildCardinality::ONE,
        };
        let mut statement = rule("s");
        statement.alts.push(AltModel {
            label: None,
            span: (0, 100),
            // `xs+=A {action at 20} A`
            refs: vec![

---

Found a 14 line (120 tokens) duplication in the following files:

• Starting at line 770 of src/bin_support/embedded.rs
• Starting at line 845 of src/bin_support/embedded.rs

            };
            let parent = counts.first().and_then(|(branch, _)| {
                ancestry.get(&(choice, *branch)).and_then(|chain| {
                    chain
                        .split_last()
                        .and_then(|(_, rest)| rest.last().copied())
                })
            });
            for (branch, _) in &counts {
                per_branch.remove(&(choice, *branch));
            }
            match parent {
                Some(parent_key) => {
                    let slot = per_branch.entry(parent_key).or_insert(Some(0));
```rust

---

Found a 21 line (119 tokens) duplication in the following files:
* Starting at line 2250 of src/bin_support/embedded.rs
* Starting at line 2312 of src/bin_support/embedded.rs

```rust
        let single_ref = ElementRef {
            label: Some("name".to_owned()),
            target: "e".to_owned(),
            token_types: Vec::new(),
            is_block: false,
            is_list: false,
            cardinality: ChildCardinality {
                min: 1,
                max: Some(1),
            },
            stable_accessor: true,
            choice_branch: Vec::new(),
            choice_arity: Vec::new(),
            choice_spans: Vec::new(),
            group_spans: Vec::new(),
            branch_spans: Vec::new(),
            leading_terminal: true,
            span: None,
            branch_local_cardinality: ChildCardinality::ONE,
            group_local_cardinality: ChildCardinality::ONE,
        };

---

Found a 18 line (115 tokens) duplication in the following files:

• Starting at line 3206 of src/bin_support/embedded.rs
• Starting at line 3438 of src/bin_support/embedded.rs

        let list_ref = || ElementRef {
            label: Some("args".to_owned()),
            target: "e".to_owned(),
            token_types: Vec::new(),
            is_block: false,
            is_list: true,
            cardinality: ChildCardinality { min: 1, max: None },
            stable_accessor: true,
            choice_branch: Vec::new(),
            choice_arity: Vec::new(),
            choice_spans: Vec::new(),
            group_spans: Vec::new(),
            branch_spans: Vec::new(),
            leading_terminal: true,
            span: None,
            branch_local_cardinality: ChildCardinality::ONE,
            group_local_cardinality: ChildCardinality::ONE,
        };
```rust

---

Found a 17 line (104 tokens) duplication in the following files:
* Starting at line 2339 of src/bin_support/embedded.rs
* Starting at line 3462 of src/bin_support/embedded.rs

```rust
                    cardinality: ChildCardinality { min: 0, max: None },
                    stable_accessor: true,
                    choice_branch: Vec::new(),
                    choice_arity: Vec::new(),
                    choice_spans: Vec::new(),
                    group_spans: Vec::new(),
                    branch_spans: Vec::new(),
                    leading_terminal: true,
                    span: None,
                    branch_local_cardinality: ChildCardinality::ONE,
                    group_local_cardinality: ChildCardinality::ONE,
                },
            ],
            children: BTreeMap::new(),
            leading_target: Some("e".to_owned()),
        });
        let m = model(vec![statement, rule("e")]);

---

Found a 19 line (103 tokens) duplication in the following files:

• Starting at line 3056 of src/bin_support/embedded.rs
• Starting at line 3226 of src/bin_support/embedded.rs

                    target: "'a'".to_owned(),
                    token_types: vec![1],
                    is_block: false,
                    is_list: false,
                    cardinality: ChildCardinality {
                        min: 1,
                        max: Some(1),
                    },
                    stable_accessor: true,
                    choice_branch: Vec::new(),
                    choice_arity: Vec::new(),
                    choice_spans: Vec::new(),
                    group_spans: Vec::new(),
                    branch_spans: Vec::new(),
                    leading_terminal: true,
                    span: None,
                    branch_local_cardinality: ChildCardinality::ONE,
                    group_local_cardinality: ChildCardinality::ONE,
                },
```rust

---

Found a 17 line (102 tokens) duplication in the following files:
* Starting at line 1990 of src/bin_support/embedded.rs
* Starting at line 2008 of src/bin_support/embedded.rs

```rust
                    label: Some("left".to_owned()),
                    target: "e".to_owned(),
                    token_types: Vec::new(),
                    is_block: false,
                    is_list: false,
                    cardinality: ChildCardinality::ONE,
                    stable_accessor: true,
                    choice_branch: Vec::new(),
                    choice_arity: Vec::new(),
                    choice_spans: Vec::new(),
                    group_spans: Vec::new(),
                    branch_spans: Vec::new(),
                    leading_terminal: true,
                    span: None,
                    branch_local_cardinality: ChildCardinality::ONE,
                    group_local_cardinality: ChildCardinality::ONE,
                },

---

Found a 17 line (102 tokens) duplication in the following files:

• Starting at line 2964 of tests/antlr4_rust_gen_cli.rs
• Starting at line 3031 of tests/antlr4_rust_gen_cli.rs

        dir.join("L.g4").as_os_str(),
        OsStr::new("--sem-patterns"),
        dir.join("patterns.toml").as_os_str(),
        OsStr::new("--sem-unknown"),
        OsStr::new("error"),
        OsStr::new("--require-full-semantics"),
        OsStr::new("--out-dir"),
        out.as_os_str(),
    ]);
    assert!(
        output.status.success(),
        "stdout: {}\nstderr: {}",
        utf8(&output.stdout),
        utf8(&output.stderr)
    );

    let lexer = fs::read_to_string(out.join("l.rs")).expect("lexer should be emitted");
```rust

</details>

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

📝 Walkthrough

Walkthrough

The generator preserves labels inside unlabeled blocks, scopes positional references to alternatives, and rejects ambiguous embedded label resolution. New fixtures and tests cover grouped labels, mixed labels, optional branches, unbounded runs, and accessor omission cases.

Changes

Label resolution and accessor generation

Layer / File(s)	Summary
Structural block lowering and generated accessors src/bin/antlr4-rust-gen.rs, tests/fixtures/antlr4-rust-gen/multi-alternative-label/T.g4, tests/antlr4_rust_gen_cli.rs	Nested labels are preserved during block lowering, alternative cardinality is scoped per branch, and regression fixtures/tests validate grouped, mixed, optional, unbounded, and rival label shapes.
Embedded label resolution src/bin_support/embedded.rs	Label occurrence tracking handles inexact cardinality, token groups, list labels, optional shadowing, repeated targets, and conflicting sibling-branch positions; unit tests cover supported reads and translation failures.

Estimated code review effort: 4 (Complex) | ~45 minutes

Sequence Diagram(s)

sequenceDiagram
  participant GrammarFixture as multi-alternative-label/T.g4
  participant Generator as antlr4-rust-gen
  participant EmbeddedResolver as embedded label resolver
  participant TypedContexts as generated typed contexts
  participant Tests as Issue 201 regression tests
  GrammarFixture->>Generator: provide grouped and alternative labels
  Generator->>TypedContexts: emit branch-aware accessors
  EmbeddedResolver->>TypedContexts: resolve embedded label positions
  Tests->>TypedContexts: parse inputs and inspect accessors
  TypedContexts-->>Tests: return labeled children or translation errors

Loading

Possibly related PRs

• ophi-dev/antlr4-rust-runtime#211: Changes label and accessor selection across token groups, optional occurrences, and alternative boundaries.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Linked Issues check	✅ Passed	The changes and tests address typed accessors for grouped labels and mixed single/list same-rule labels as requested in #201.
Out of Scope Changes check	✅ Passed	The additional label-resolution and choice-branch changes support the accessor fix and stay within the issue's scope.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly matches the main codegen fix for group-nested label accessors and mixed same-rule labels.

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/201-label-accessors

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[github-actions]

📊 Source Code Metrics (this PR vs main)

File	Cyclomatic	Cognitive	Functions	LLOC	MI
src/bin/antlr4-rust-gen.rs	2506 (main: 2383) 🔴	1581 (main: 1486) 🔴	541 (main: 536) 🔴	4341 (main: 4191) 🔴	0 ⚪
src/tree.rs	340 (main: 330) 🔴	93 (main: 89) 🔴	176 (main: 174) 🔴	474 (main: 455) 🔴	0 ⚪
src/bin_support/embedded.rs	500 (main: 166) 🔴	327 (main: 105) 🔴	66 (main: 36) 🔴	739 (main: 248) 🔴	0 ⚪

Generated by mehen v1.7.0 — the code quality watcher.

[claude]

Claude Code review skipped — usage limit reached.

You've hit your weekly limit · resets Jul 29, 8pm (UTC) Re-run the workflow once the quota resets.

[codecov]

Codecov Report

❌ Patch coverage is 93.00184% with 38 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
src/bin/antlr4-rust-gen.rs	92.60%	37 Missing ⚠️
src/tree.rs	97.67%	1 Missing ⚠️

📢 Thoughts on this report? Let us know!

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: f69861457c

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 742adfcc39

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[tinovyatkin]

@coderabbitai review

[coderabbitai]

✅ Action performed

Review finished.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

[coderabbitai]

Actionable comments posted: 1

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/bin_support/embedded.rs`:
- Around line 384-395: The list handling in the alt.refs indexing loop must
poison occurrence_by_target for list elements with a real target instead of
continuing without updating the bucket. Keep empty-target token groups excluded
from indexing, but mark a list target as inexact/invalid so later same-target
labels remain unresolved rather than using occurrence 0; add coverage for the
list-before-single ordering such as errors+=unary followed by name=unary.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 96eb9291-2b63-4f43-98a4-141c29faec52

📥 Commits

Reviewing files that changed from the base of the PR and between f698614 and 54fdf7a.

📒 Files selected for processing (3)

• src/bin/antlr4-rust-gen.rs
• src/bin_support/embedded.rs
• tests/fixtures/antlr4-rust-gen/multi-alternative-label/T.g4

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d64f014fe7

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 2

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/bin/antlr4-rust-gen.rs (1)

14068-14132: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Add the required Insta Clippy allowance.

grouped_and_mixed_same_rule_labels_emit_accessors_without_crossing_branches uses insta::assert_snapshot! but does not include #[allow(clippy::disallowed_methods)]; bare test functions with Insta assertion macros need this allowance per the repository rules.

Proposed fix

+    #[allow(clippy::disallowed_methods)]
     #[test]
     fn grouped_and_mixed_same_rule_labels_emit_accessors_without_crossing_branches() {

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/bin/antlr4-rust-gen.rs` around lines 14068 - 14132, Add
#[allow(clippy::disallowed_methods)] to the
grouped_and_mixed_same_rule_labels_emit_accessors_without_crossing_branches test
function, directly alongside its existing #[test] attribute, without changing
the snapshot assertions.

Source: Coding guidelines

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/bin_support/embedded.rs`:
- Around line 382-393: The resolve_label method must not return the first match
when body_offset is None. Collect matches from all alternatives, accept only
when they resolve to one provably identical read, and otherwise reject the
conflicting label; preserve the existing scoped lookup behavior when body_offset
selects a single alternative.
- Around line 426-441: Update the block-label handling in translate_element_read
so it does not emit a read when the action position cannot be compared with the
referenced block’s child positions. Carry element and action source spans
through the relevant model and restrict terminal lookup to children before the
action; otherwise reject the read instead of returning Some((element.clone(),
0)) for every empty target.

---

Outside diff comments:
In `@src/bin/antlr4-rust-gen.rs`:
- Around line 14068-14132: Add #[allow(clippy::disallowed_methods)] to the
grouped_and_mixed_same_rule_labels_emit_accessors_without_crossing_branches test
function, directly alongside its existing #[test] attribute, without changing
the snapshot assertions.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 5179fac2-fcf4-4f7a-8cd9-6eef4e6df2f4

📥 Commits

Reviewing files that changed from the base of the PR and between 54fdf7a and 3de4d48.

⛔ Files ignored due to path filters (4)

• src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_branch_hazard_context.snap is excluded by !**/*.snap
• src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_branch_rival_context.snap is excluded by !**/*.snap
• src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_mixed_unbounded_context.snap is excluded by !**/*.snap
• src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_nested_group_context.snap is excluded by !**/*.snap

📒 Files selected for processing (2)

• src/bin/antlr4-rust-gen.rs
• src/bin_support/embedded.rs

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 3de4d48e21

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 08748bb646

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 3

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/bin_support/embedded.rs`:
- Around line 416-420: Update same_label_read to compare the read-mode fields
consumed by translate_element_read: include is_block and avoid using token_types
for block-read equivalence. Preserve comparisons for label, target, and list
mode, and add a test covering equivalent block labels across alternatives such
as x=(A | B) and x=(C | D).
- Around line 397-402: Update the alternative-resolution logic around
resolve_label_in_alt so nondeclaring alternatives are inspected for children
that can satisfy the selected positional, list, or block read instead of being
unconditionally skipped. Reject the unscoped read when such a child exists,
preserving unset-label behavior when no unlabelled alternative can satisfy it.
Add a regression case covering r: x=A | A with a subsequent $x.text lookup.
- Around line 437-454: Update the repeated-list-label resolution in the
element.is_list branch to require all declares_label(candidate) declarations to
use the same target and read mode as element before returning the resolved
iterator. Preserve the existing target-exclusion check, but return None when
declarations such as xs+=A and xs+=B differ instead of selecting only the first
target.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: b0963be6-9a7a-4691-92af-803684dcbdb1

📥 Commits

Reviewing files that changed from the base of the PR and between 3de4d48 and b773e8a.

📒 Files selected for processing (1)

• src/bin_support/embedded.rs

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: b773e8a1af

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: bfd07041e1

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/bin_support/embedded.rs`:
- Around line 80-96: Retain the full enclosing choice ancestry in ElementRef
rather than only the innermost branch, and update can_coexist_with to report a
conflict when any shared choice has different alternatives. In
src/bin/antlr4-rust-gen.rs:2763-2767, append each current choice branch to
inherited ancestry. In src/bin_support/embedded.rs:1602-1677, add a
nested-choice regression covering both the safe inner action and a genuinely
sequential follower.
- Around line 444-460: Update alt_can_satisfy_read and the structural lowering
that builds AltModel.refs so unlabeled ElementKind::Range terminals are
preserved or otherwise considered for block reads. Ensure an unlabeled range
cannot satisfy an unscoped read when its target element is unset, while
retaining valid labeled terminal behavior, and add a regression test for r :
x=(A | B) | 'c'..'d'; with an unscoped $x read.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 78099ce7-be6e-49fe-aba5-e65e4dc5e475

📥 Commits

Reviewing files that changed from the base of the PR and between b773e8a and 4f86861.

⛔ Files ignored due to path filters (1)

• src/bin/snapshots/antlr4_rust_gen__tests__left_recursive_label_alternatives.snap is excluded by !**/*.snap

📒 Files selected for processing (2)

• src/bin/antlr4-rust-gen.rs
• src/bin_support/embedded.rs

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 4f86861cde

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 83e456b443

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 10edafd836

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 8a88072f5b

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

antlr-rust-runtime/src/bin/antlr4-rust-gen.rs

Lines 9229 to 9233 in 8616aad

	cardinalities.push(if is_list {
	sum_child_cardinalities(matching.iter().map(|(_, element)| element.cardinality))
	} else {
	matching[0].1.cardinality
	});

Aggregate exhaustive declarations into required cardinality

For r : (x=A | x=B) EOF;, every parse binds x, yet the generated accessor is fn x(&self) -> Option<TerminalNode> rather than the required-child Result used for other mandatory labels. The first declaration's 0..1 cardinality reflects only that its individual choice branch may not be taken; using it for the entire top-level alternative ignores that every sibling branch has a compatible declaration. Fold all nested declarations by choice coverage before deriving the accessor cardinality.

AGENTS.md reference: AGENTS.md:L5-L9

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Condition prefix counts on the label's enclosing group

For r : (A x=A)? EOF;, the generated RContext omits the valid x() accessor. On every parse where x is bound, the optional group is necessarily taken and the preceding A count is exactly one, while on the absent path child_tokens(A).nth(1) is safely empty; however, replacing the prefix cardinality with branch_local_cardinality retains the enclosing group's 0..1 quantifier, so the exactness check rejects it. Condition shared enclosing groups as taken when computing a declaration's prefix, analogous to the action-path handling.

AGENTS.md reference: AGENTS.md:L5-L9

Useful? React with 👍 / 👎.

[tinovyatkin]

Confirmed and fixed in 058080f. r : (A x=A)? EOF; omitted a valid x(); it now emits it.

Your reasoning is what the fix encodes: "on every parse where x is bound, the optional group is necessarily taken and the preceding A count is exactly one, while on the absent path nth(1) is safely empty." Both cardinality and branch_local_cardinality reported 0..1 from the group's ?, so neither could express that.

The accessor path now does what the embedded path already did — when a ref shares every optional group with the label, those groups are taken wherever the label is bound, so the quantifier-free group_local_cardinality applies. One detail that cost me a cycle: exact_target_cardinality judges exactness from branch_local_cardinality, so overriding cardinality alone had no effect; both fields have to carry the on-path figure.

Pinned as OptionalGroupSharedWithLabel in the corpus.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: e17fe88e4e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

antlr-rust-runtime/src/bin/antlr4-rust-gen.rs

Lines 9246 to 9249 in 058080f

	cardinalities.push(if is_list {
	sum_child_cardinalities(matching.iter().map(|(_, element)| element.cardinality))
	} else {
	matching[0].1.cardinality

Preserve required cardinality across exhaustive declarations

When one scalar label is declared in every branch of a nested exhaustive choice, taking only the first declaration's branch-relaxed cardinality incorrectly makes the label optional. For r : (x=q | x=q) EOF;, the generated context exposes x() -> Option<QContext> even though every parse assigns x; the corresponding required q() child uses Result<_, MissingChildError>. Aggregate the declarations through their recorded choice ancestry before computing the accessor cardinality so exhaustive labels retain required-child semantics.

AGENTS.md reference: AGENTS.md:L5-L9

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

antlr-rust-runtime/src/bin/antlr4-rust-gen.rs

Lines 9413 to 9418 in 28b7511

	let has_following_target = alternative.refs[first_position + 1..]
	.iter()
	.any(|following| {
	context_ref_can_match_target(following, target) && following.cardinality.max != Some(0)
	});
	(!has_following_target).then_some(ContextLabelSelector::LastAfter(start))

Reject last-match reads shadowed by the next loop prefix

When repetition comes from an enclosing group and the scalar label is optional within each iteration, checking only source-level followers does not make .last() faithful. For r : (A x=A?)+ EOF;, parsing aaa binds x to the second token in the first iteration, then leaves it unchanged when the final iteration's optional x is absent; the generated skip(1).last() instead returns the third, unlabeled prefix token. Account for matching refs before the label that can recur in a later iteration, or decline this accessor.

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 6e30862762

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Update terminal state before continuing past collapsed blocks

Fresh evidence after the leading_terminal fix is A:'a'; B:'b'; r @after {$x.text}: (B) x=A | x='a';: the collapsed (B) ref is pushed with leading_terminal: true, but the immediate continue bypasses the loop's seen_terminal = true update, so x=A is also classified as leading. The mixed token/literal merge then accepts incompatible coordinate systems and retains terminal_children().nth(0); parsing ba reports b for x instead of a. Mark the collapsed block as terminal-bearing before continuing.

Useful? React with 👍 / 👎.

[tinovyatkin]

Confirmed and fixed in a962bbc.

Root cause was one missing line rather than the merge logic. A token-only group
collapses into a single ElementRef, and that arm continued past the loop's
seen_terminal = true update — so (B) never registered as a terminal and
every element after it was still tagged leading_terminal: true. x=A then
looked like a leading terminal, which made it compare equal-enough to x='a'
(a genuine leading terminal) under same_read_as_element, and the two got
merged despite indexing different coordinate systems: x=A wants
child_tokens(A).nth(i) (same-type index), x='a' wants the block-positional
one.

Fix is in collect_structural_context_refs_with_cardinality: the collapsed
group is a terminal child, so record it before skipping the rest of the body.
$x on your grammar now declines loudly instead of resolving.

Pinned as CollapsedBlockIsTerminal in the label-resolution corpus. Re-verified:
357/357 conformance, Avro IDL +20/−0, Kotlin byte-identical.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 39d8b47d23

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: a962bbc169

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d82b73ceb7

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[tinovyatkin]

parse-bench flake on 5dcbe9e — investigated, not a regression

The first run failed on java/issue-174-return-expression.java at 1.35×
(0.029ms vs 0.021ms). It passes on re-run. Rather than just re-running I checked
whether a regression was possible, and it is not:

The runtime is additive only. Every non-generator file changed against
origin/main is src/tree.rs plus its snapshot, and the diff has zero deleted
lines — one new method, labeled_terminal_children, which nothing on the parse
path calls.

The Java lane's generated parser has no parse-path change. It does differ from
baseline, by exactly three new pub fn label accessors on one context (all
uncalled, and the lexer is byte-identical). Deleting just those three functions
makes the file byte-identical to the baseline build — 2,599,076 bytes either
way. There is no code on the parse path to be slower.

The failure signature is noise. Three parse-bench failures across 17 runs on
this branch, each a different fixture and each just over the 1.15× gate:

Run	Fixture	Ratio
14:08	kotlin/ktor-openapi-describe-route-test.kt	1.16×
16:05	kotlin/kotlinx-coroutines-flow-limit.kt	1.18×
17:38	java/issue-174-return-expression.java	1.35×

The java fixture is a 50-byte file — class C { int m() { return 1; } } —
timed at 21µs, so the "regression" is 8µs on a shared CI runner. Small fixtures
sit close enough to the gate that scheduler jitter alone can trip it.

Not proposing a threshold change here, since that would be scope creep on a
codegen PR and the gate does catch real regressions on the large fixtures. Flagging
it as a candidate for a follow-up issue: a minimum-duration floor (or best-of-N)
for sub-100µs fixtures would remove this class of flake without weakening the gate
where it matters.