Change Edge::label from optional to required

crates/codegen/language/definition/src/model/manifest.rs

@@ -179,6 +179,8 @@ pub struct Topic {
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum PredefinedLabel {
+    Root,
+    Unrecognized,
     Item,
     Variant,
     Separator,

crates/codegen/runtime/cargo/crate/src/runtime/cst/edge_label.rs.jinja2

@@ -34,3 +34,9 @@ pub enum EdgeLabel {
 }
 
 impl crate::cst::EdgeLabelExtensions for EdgeLabel {}
+
+impl Default for EdgeLabel {
+    fn default() -> Self {
+        Self::Root
+    }
+}

crates/codegen/runtime/cargo/crate/src/runtime/parser/lexer/mod.rs

@@ -99,10 +99,7 @@ pub(crate) trait Lexer {
         let end = input.position();
 
         ParserResult::r#match(
-            vec![Edge::anonymous(Node::terminal(
-                kind,
-                input.content(start..end),
-            ))],
+            vec![Edge::root(Node::terminal(kind, input.content(start..end)))],
             vec![],
         )
     }
@@ -132,10 +129,7 @@ pub(crate) trait Lexer {
             return ParserResult::no_match(None, vec![kind]);
         }
         let end = input.position();
-        children.push(Edge::anonymous(Node::terminal(
-            kind,
-            input.content(start..end),
-        )));
+        children.push(Edge::root(Node::terminal(kind, input.content(start..end))));
 
         let restore = input.position();
         if let ParserResult::Match(r#match) = self.trailing_trivia(input) {

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser_support/parser_function.rs

@@ -1,6 +1,6 @@
 use std::rc::Rc;
 
-use crate::cst::{Edge, Node, TerminalKind, TerminalKindExtensions, TextIndex};
+use crate::cst::{Edge, EdgeLabel, Node, TerminalKind, TerminalKindExtensions, TextIndex};
 use crate::parser::lexer::Lexer;
 use crate::parser::parser_support::context::ParserContext;
 use crate::parser::parser_support::parser_result::{
@@ -84,11 +84,18 @@ where
                 } else {
                     TerminalKind::UNRECOGNIZED
                 };
+
+                let label = if kind == TerminalKind::UNRECOGNIZED {
+                    EdgeLabel::Unrecognized
+                } else {
+                    EdgeLabel::default()
+                };
+
                 let node = Node::terminal(kind, input.to_string());
                 let tree = if no_match.kind.is_none() || start.utf8 == 0 {
                     node
                 } else {
-                    trivia_nodes.push(Edge::anonymous(node));
+                    trivia_nodes.push(Edge { label, node });
                     Node::nonterminal(no_match.kind.unwrap(), trivia_nodes)
                 };
                 ParseOutput {
@@ -144,9 +151,19 @@ where
                     } else {
                         TerminalKind::UNRECOGNIZED
                     };
+
+                    let label = if kind == TerminalKind::UNRECOGNIZED {
+                        EdgeLabel::Unrecognized
+                    } else {
+                        EdgeLabel::default()
+                    };
+
                     let skipped_node = Node::terminal(kind, input[start..].to_string());
                     let mut new_children = topmost_node.children.clone();
-                    new_children.push(Edge::anonymous(skipped_node));
+                    new_children.push(Edge {
+                        label,
+                        node: skipped_node,
+                    });
 
                     let start_index = stream.text_index_at(start);
                     let mut errors = stream.into_errors();

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser_support/parser_result.rs

@@ -48,18 +48,18 @@ impl ParserResult {
     pub fn with_kind(self, new_kind: NonterminalKind) -> ParserResult {
         match self {
             ParserResult::Match(r#match) => ParserResult::r#match(
-                vec![Edge::anonymous(Node::nonterminal(new_kind, r#match.nodes))],
+                vec![Edge::root(Node::nonterminal(new_kind, r#match.nodes))],
                 r#match.expected_terminals,
             ),
             ParserResult::IncompleteMatch(incomplete_match) => ParserResult::incomplete_match(
-                vec![Edge::anonymous(Node::nonterminal(
+                vec![Edge::root(Node::nonterminal(
                     new_kind,
                     incomplete_match.nodes,
                 ))],
                 incomplete_match.expected_terminals,
             ),
             ParserResult::SkippedUntil(skipped) => ParserResult::SkippedUntil(SkippedUntil {
-                nodes: vec![Edge::anonymous(Node::nonterminal(new_kind, skipped.nodes))],
+                nodes: vec![Edge::root(Node::nonterminal(new_kind, skipped.nodes))],
                 ..skipped
             }),
             ParserResult::NoMatch(no_match) => {
@@ -77,13 +77,13 @@ impl ParserResult {
             label: prev_label, ..
         }) = self.significant_node_mut()
         {
-            *prev_label = Some(label);
+            *prev_label = label;
         }
         // Also allow to name a single trivia terminal node
         else if let ParserResult::Match(Match { nodes, .. }) = &mut self {
             if let [node] = nodes.as_mut_slice() {
                 if node.as_terminal().is_some_and(|tok| tok.kind.is_trivia()) {
-                    node.label = Some(label);
+                    node.label = label;
                 }
             }
         }
@@ -176,7 +176,7 @@ impl PrattElement {
             Self::Binary { kind, nodes, .. }
             | Self::Prefix { kind, nodes, .. }
             | Self::Postfix { kind, nodes, .. } => {
-                vec![Edge::anonymous(Node::nonterminal(kind, nodes))]
+                vec![Edge::root(Node::nonterminal(kind, nodes))]
             }
         }
     }

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser_support/precedence_helper.rs

@@ -174,7 +174,7 @@ impl PrecedenceHelper {
                 let left_nodes = match left {
                     Some(Expression { nodes }) => {
                         vec![Edge {
-                            label: Some(left_label),
+                            label: left_label,
                             node: Node::nonterminal(child_kind, nodes),
                         }]
                     }
@@ -185,7 +185,7 @@ impl PrecedenceHelper {
                 let right_nodes = match right {
                     Some(Expression { nodes }) => {
                         vec![Edge {
-                            label: Some(right_label),
+                            label: right_label,
                             node: Node::nonterminal(child_kind, nodes),
                         }]
                     }
@@ -197,7 +197,7 @@ impl PrecedenceHelper {
 
                 Expression {
                     nodes: vec![Edge {
-                        label: Some(EdgeLabel::Variant),
+                        label: EdgeLabel::Variant,
                         node: Node::nonterminal(kind, children),
                     }],
                 }

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser_support/separated_helper.rs

@@ -56,10 +56,17 @@ impl SeparatedHelper {
                             } else {
                                 TerminalKind::UNRECOGNIZED
                             };
-                            accum.push(Edge::anonymous(Node::terminal(
-                                kind,
-                                input.content(skipped_range.utf8()),
-                            )));
+
+                            let label = if kind == TerminalKind::UNRECOGNIZED {
+                                EdgeLabel::Unrecognized
+                            } else {
+                                EdgeLabel::default()
+                            };
+
+                            accum.push(Edge {
+                                label,
+                                node: Node::terminal(kind, input.content(skipped_range.utf8())),
+                            });
                             input.emit(ParseError::new(
                                 skipped_range,
                                 incomplete.expected_terminals,

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser_support/sequence_helper.rs

@@ -160,10 +160,17 @@ impl SequenceHelper {
                     } else {
                         TerminalKind::UNRECOGNIZED
                     };
-                    running.nodes.push(Edge::anonymous(Node::terminal(
+
+                    let label = if kind == TerminalKind::UNRECOGNIZED {
+                        EdgeLabel::Unrecognized
+                    } else {
+                        EdgeLabel::default()
+                    };
+
+                    running.nodes.push(Edge{label, node: Node::terminal(
                         kind,
                         std::mem::take(&mut running.skipped),
-                    )));
+                    )});
                     running.nodes.extend(next.nodes);
 
                     self.result = State::Running(ParserResult::Match(Match {

crates/codegen/runtime/cargo/wasm/src/runtime/interface/cst.wit.jinja2

@@ -142,7 +142,7 @@ interface cst {
     /// Represents a connection between nodes in the syntax tree.
     record edge {
         /// Optional label describing the relationship between nodes.
-        label: option<edge-label>,
+        label: edge-label,
         /// The target node of this edge.
         node: node,
     }
@@ -167,7 +167,7 @@ interface cst {
         /// Returns the current node under the cursor.
         node: func() -> node;
         /// Returns the label of the edge from the parent to the current node, if any.
-        label: func() -> option<edge-label>;
+        label: func() -> edge-label;
 
         /// Returns the current text offset of the cursor.
         text-offset: func() -> text-index;

crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/ast/selectors.rs.jinja2

@@ -147,40 +147,38 @@ impl Helper {
     }
 
     fn try_select(&mut self, target_label: EdgeLabel) -> Option<Node> {
-        let (label, node) = self.current()?;
+        let edge = self.current()?;
 
-        if label == target_label {
+        if edge.label == target_label {
             self.index += 1;
-            Some(node.clone())
+            Some(edge.node)
         } else {
             None
         }
     }
 
-    fn current(&mut self) -> Option<(EdgeLabel, Node)> {
+    fn current(&mut self) -> Option<Edge> {
         loop {
-            let Edge { label, node } = self.node.children.get(self.index)?;
+            let edge = self.node.children.get(self.index)?;
 
-            match label {
-                // Skip unlabeled nodes:
-                | None
+            match edge.label {
                 // Skip trivia:
-                | Some(EdgeLabel::LeadingTrivia | EdgeLabel::TrailingTrivia) => {
+                | EdgeLabel::LeadingTrivia | EdgeLabel::TrailingTrivia => {
                     self.index += 1;
                     continue;
                 }
                 // Otherwise, return the edge:
-                Some(other_label) => {
-                    return Some((*other_label, node.clone()));
+                _ => {
+                    return Some(edge.clone());
                 }
             }
         }
     }
 
     fn finalize(mut self) -> Result<()> {
         match self.current() {
-            Some((label, _)) => {
-                Err(format!("Unrecognized child with label '{label}'. Creating AST types from incorrect/incomplete CST nodes is not supported yet."))
+            Some(edge) => {
+                Err(format!("Unrecognized child with label '{label}'. Creating AST types from incorrect/incomplete CST nodes is not supported yet.", label = edge.label))
             }
             None => {
                 Ok(())

crates/codegen/runtime/cargo/wasm/src/runtime/wrappers/cst/mod.rs

@@ -182,7 +182,7 @@ impl IntoFFI<ffi::Edge> for rust::Edge {
     #[inline]
     fn _into_ffi(self) -> ffi::Edge {
         ffi::Edge {
-            label: self.label.map(IntoFFI::_into_ffi),
+            label: self.label._into_ffi(),
             node: self.node._into_ffi(),
         }
     }
@@ -219,8 +219,8 @@ define_refcell_wrapper! { Cursor {
         self._borrow_ffi().node()._into_ffi()
     }
 
-    fn label(&self) -> Option<ffi::EdgeLabel> {
-        self._borrow_ffi().label().map(IntoFFI::_into_ffi)
+    fn label(&self) -> ffi::EdgeLabel {
+        self._borrow_ffi().label()._into_ffi()
     }
 
     fn text_offset(&self) -> ffi::TextIndex {