Change Edge::label from optional to required

.changeset/metal-penguins-flow.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/slang": patch
+---
+
+Make `Edge::label` a required field instead of being optional.

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

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

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

@@ -39,3 +39,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(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,7 +1,8 @@
 use std::rc::Rc;
 
 use crate::cst::{
-    Edge, Node, NonterminalKind, NonterminalNode, TerminalKind, TerminalKindExtensions, TextIndex,
+    Edge, EdgeLabel, Node, NonterminalKind, NonterminalNode, TerminalKind, TerminalKindExtensions,
+    TextIndex,
 };
 use crate::parser::lexer::Lexer;
 use crate::parser::parser_support::context::ParserContext;
@@ -81,13 +82,16 @@ where
                     }
                 }
                 let input = &input[start.utf8..];
-                let kind = if input.is_empty() {
-                    TerminalKind::MISSING
+                let (kind, label) = if input.is_empty() {
+                    (TerminalKind::MISSING, EdgeLabel::Missing)
                 } else {
-                    TerminalKind::UNRECOGNIZED
+                    (TerminalKind::UNRECOGNIZED, EdgeLabel::Unrecognized)
                 };
+
                 let node = Node::terminal(kind, input.to_string());
-                children.push(Edge::anonymous(node));
+
+                children.push(Edge { label, node });
+
                 ParseOutput {
                     tree: Rc::new(NonterminalNode::new(topmost_kind, children)),
                     errors: vec![ParseError::new(
@@ -136,14 +140,18 @@ where
                     } else {
                         start
                     };
-                    let kind = if input[start..].is_empty() {
-                        TerminalKind::MISSING
+                    let (kind, label) = if input[start..].is_empty() {
+                        (TerminalKind::MISSING, EdgeLabel::Missing)
                     } else {
-                        TerminalKind::UNRECOGNIZED
+                        (TerminalKind::UNRECOGNIZED, EdgeLabel::Unrecognized)
                     };
+
                     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

@@ -47,18 +47,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) => ParserResult::no_match(no_match.expected_terminals),
@@ -74,13 +74,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;
                 }
             }
         }
@@ -173,7 +173,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

@@ -51,15 +51,16 @@ impl SeparatedHelper {
                     match skip_until_with_nested_delims::<_, LexCtx>(input, lexer, separator) {
                         // A separator was found, so we can recover the incomplete match
                         Some((found, skipped_range)) if found == separator => {
-                            let kind = if skipped_range.is_empty() {
-                                TerminalKind::MISSING
+                            let (kind, label) = if skipped_range.is_empty() {
+                                (TerminalKind::MISSING, EdgeLabel::Missing)
                             } else {
-                                TerminalKind::UNRECOGNIZED
+                                (TerminalKind::UNRECOGNIZED, EdgeLabel::Unrecognized)
                             };
-                            accum.push(Edge::anonymous(Node::terminal(
-                                kind,
-                                input.content(skipped_range.utf8()),
-                            )));
+
+                            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

@@ -155,15 +155,16 @@ impl SequenceHelper {
                     });
                     debug_assert_eq!(next_terminal, Ok(Some(running.found)));
 
-                    let kind = if running.skipped.is_empty() {
-                        TerminalKind::MISSING
+                    let (kind, label) = if running.skipped.is_empty() {
+                        (TerminalKind::MISSING, EdgeLabel::Missing)
                     } else {
-                        TerminalKind::UNRECOGNIZED
+                        (TerminalKind::UNRECOGNIZED, EdgeLabel::Unrecognized)
                     };
-                    running.nodes.push(Edge::anonymous(Node::terminal(
+
+                    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

@@ -143,8 +143,8 @@ interface cst {
 
     /// Represents a connection between nodes in the syntax tree.
     record edge {
-        /// Optional label describing the relationship between nodes.
-        label: option<edge-label>,
+        /// Describes the relationship between this node and its parent.
+        label: edge-label,
         /// The target node of this edge.
         node: node,
     }
@@ -168,8 +168,8 @@ 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>;
+        /// Returns a label that describes the relationship between the current node and its parent.
+        label: func() -> edge-label;
 
         /// Returns the current text offset of the cursor.
         text-offset: func() -> text-index;