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

src/bin/snapshots/antlr4_rust_gen__tests__left_recursive_label_alternatives.snap

@@ -25,6 +25,25 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: true,
+                span: None,
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
             ElementRef {
                 label: None,
@@ -41,6 +60,30 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: true,
+                span: Some(
+                    (
+                        135,
+                        139,
+                    ),
+                ),
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
             ElementRef {
                 label: Some(
@@ -57,6 +100,30 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: false,
+                span: Some(
+                    (
+                        146,
+                        147,
+                    ),
+                ),
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
         ],
         children: {
@@ -99,6 +166,25 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: true,
+                span: None,
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
             ElementRef {
                 label: None,
@@ -115,6 +201,30 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: true,
+                span: Some(
+                    (
+                        190,
+                        194,
+                    ),
+                ),
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
             ElementRef {
                 label: Some(
@@ -131,6 +241,30 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: false,
+                span: Some(
+                    (
+                        201,
+                        202,
+                    ),
+                ),
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
         ],
         children: {
@@ -173,6 +307,30 @@ expression: "model.rules[1].alts"
                     ),
                 },
                 stable_accessor: true,
+                choice_branch: [],
+                choice_arity: [],
+                choice_spans: [],
+                group_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
+                group_spans: [],
+                branch_spans: [],
+                leading_terminal: true,
+                span: Some(
+                    (
+                        238,
+                        241,
+                    ),
+                ),
+                branch_local_cardinality: ChildCardinality {
+                    min: 1,
+                    max: Some(
+                        1,
+                    ),
+                },
             },
         ],
         children: {

src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_branch_hazard_context.snap

@@ -0,0 +1,44 @@
+---
+source: src/bin/antlr4-rust-gen.rs
+expression: context(name)
+---
+
+    pub fn child_count(&self) -> usize {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.child_count(),
+            __GeneratedRuleContext::Active { context, .. } => context.child_count(),
+        }
+    }
+
+    pub fn start(&self) -> __GeneratedTokenView {
+        let token = match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.start(),
+            __GeneratedRuleContext::Active { context, tokens, .. } => context.start(tokens),
+        };
+        __GeneratedTokenView { text: token.map(|token| token.text_or_empty().to_owned()).unwrap_or_default() }
+    }
+
+    pub fn text(&self) -> String {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.text(),
+            __GeneratedRuleContext::Active { context, storage, tokens } => context.text(storage, tokens),
+        }
+    }
+    pub fn unary(&self) -> Result<UnaryContext<'a>, MissingChildError> {
+        __rule_children(self.__node, 4)
+            .next()
+            .map(|node| UnaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
+            .ok_or_else(|| MissingChildError::new("BranchHazardContext", "unary"))
+    }
+    pub fn star_token(&self) -> Option<TerminalNode<'a>> {
+        __token_children(self.__node, 8)
+            .next()
+            .map(TerminalNode::new)
+    }
+    pub fn num_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
+        __token_children(self.__node, 14)
+            .next()
+            .map(TerminalNode::new)
+            .ok_or_else(|| MissingChildError::new("BranchHazardContext", "NUM"))
+    }
+}

src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_branch_rival_context.snap

@@ -0,0 +1,39 @@
+---
+source: src/bin/antlr4-rust-gen.rs
+expression: context(name)
+---
+
+    pub fn child_count(&self) -> usize {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.child_count(),
+            __GeneratedRuleContext::Active { context, .. } => context.child_count(),
+        }
+    }
+
+    pub fn start(&self) -> __GeneratedTokenView {
+        let token = match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.start(),
+            __GeneratedRuleContext::Active { context, tokens, .. } => context.start(tokens),
+        };
+        __GeneratedTokenView { text: token.map(|token| token.text_or_empty().to_owned()).unwrap_or_default() }
+    }
+
+    pub fn text(&self) -> String {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.text(),
+            __GeneratedRuleContext::Active { context, storage, tokens } => context.text(storage, tokens),
+        }
+    }
+    pub fn unary(&self) -> Result<UnaryContext<'a>, MissingChildError> {
+        __rule_children(self.__node, 4)
+            .next()
+            .map(|node| UnaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
+            .ok_or_else(|| MissingChildError::new("BranchRivalContext", "unary"))
+    }
+    pub fn num_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
+        __token_children(self.__node, 14)
+            .next()
+            .map(TerminalNode::new)
+            .ok_or_else(|| MissingChildError::new("BranchRivalContext", "NUM"))
+    }
+}

src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_closed_repeat_prefix_context.snap

@@ -0,0 +1,39 @@
+---
+source: src/bin/antlr4-rust-gen.rs
+expression: "context(\"ClosedRepeatPrefixContext\")"
+---
+
+    pub fn child_count(&self) -> usize {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.child_count(),
+            __GeneratedRuleContext::Active { context, .. } => context.child_count(),
+        }
+    }
+
+    pub fn start(&self) -> __GeneratedTokenView {
+        let token = match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.start(),
+            __GeneratedRuleContext::Active { context, tokens, .. } => context.start(tokens),
+        };
+        __GeneratedTokenView { text: token.map(|token| token.text_or_empty().to_owned()).unwrap_or_default() }
+    }
+
+    pub fn text(&self) -> String {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.text(),
+            __GeneratedRuleContext::Active { context, storage, tokens } => context.text(storage, tokens),
+        }
+    }
+    pub fn star_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
+        __token_children(self.__node, 8).map(TerminalNode::new)
+    }
+    pub fn ident_tokens(&self) -> impl Iterator<Item = TerminalNode<'a>> + '_ {
+        __token_children(self.__node, 13).map(TerminalNode::new)
+    }
+    pub fn num_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
+        __token_children(self.__node, 14)
+            .next()
+            .map(TerminalNode::new)
+            .ok_or_else(|| MissingChildError::new("ClosedRepeatPrefixContext", "NUM"))
+    }
+}

src/bin/snapshots/antlr4_rust_gen__tests__multi_alternative_label_exhaustive_prefix_context.snap

@@ -0,0 +1,43 @@
+---
+source: src/bin/antlr4-rust-gen.rs
+expression: "context(\"ExhaustivePrefixContext\")"
+---
+
+    pub fn child_count(&self) -> usize {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.child_count(),
+            __GeneratedRuleContext::Active { context, .. } => context.child_count(),
+        }
+    }
+
+    pub fn start(&self) -> __GeneratedTokenView {
+        let token = match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.start(),
+            __GeneratedRuleContext::Active { context, tokens, .. } => context.start(tokens),
+        };
+        __GeneratedTokenView { text: token.map(|token| token.text_or_empty().to_owned()).unwrap_or_default() }
+    }
+
+    pub fn text(&self) -> String {
+        match &self.__node {
+            __GeneratedRuleContext::Stored(node) => node.text(),
+            __GeneratedRuleContext::Active { context, storage, tokens } => context.text(storage, tokens),
+        }
+    }
+    pub fn unary_children(&self) -> impl Iterator<Item = UnaryContext<'a>> + '_ {
+        __rule_children(self.__node, 4)
+            .map(move |node| UnaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
+    }
+    pub fn num_token(&self) -> Result<TerminalNode<'a>, MissingChildError> {
+        __token_children(self.__node, 14)
+            .next()
+            .map(TerminalNode::new)
+            .ok_or_else(|| MissingChildError::new("ExhaustivePrefixContext", "NUM"))
+    }
+    pub fn pick(&self) -> Result<UnaryContext<'a>, MissingChildError> {
+        __rule_children(self.__node, 4)
+            .nth(1)
+            .map(|node| UnaryContext::__from_child_node(node, self.__invocation_states.as_deref()))
+            .ok_or_else(|| MissingChildError::new("ExhaustivePrefixContext", "pick"))
+    }
+}