Change ParseOutput to return a NonTerminal instead of a Node

crates/codegen/runtime/cargo/crate/src/runtime/compilation/internal_builder.rs

@@ -1,6 +1,7 @@
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
+use metaslang_cst::nodes::Node;
 use semver::Version;
 
 use crate::compilation::{CompilationUnit, File};
@@ -43,7 +44,10 @@ impl InternalCompilationBuilder {
 
         let import_paths = self.imports.extract(parse_output.create_tree_cursor());
 
-        let file = File::new(id.clone(), parse_output.tree().clone());
+        let file = File::new(
+            id.clone(),
+            Node::Nonterminal(Rc::clone(parse_output.tree())),
+        );
         self.files.insert(id, file);
 
         AddFileResponse { import_paths }

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

@@ -94,7 +94,7 @@ pub(crate) trait Lexer {
             .is_some_and(|t| t.accepted_as(kind))
         {
             input.set_position(start);
-            return ParserResult::no_match(None, vec![kind]);
+            return ParserResult::no_match(vec![kind]);
         }
         let end = input.position();
 
@@ -129,7 +129,7 @@ pub(crate) trait Lexer {
             .is_some_and(|t| t.accepted_as(kind))
         {
             input.set_position(restore);
-            return ParserResult::no_match(None, vec![kind]);
+            return ParserResult::no_match(vec![kind]);
         }
         let end = input.position();
         children.push(Edge::anonymous(Node::terminal(

crates/codegen/runtime/cargo/crate/src/runtime/parser/parse_output.rs

@@ -1,14 +1,16 @@
-use crate::cst::{Cursor, Node, TextIndex};
+use std::rc::Rc;
+
+use crate::cst::{Cursor, NonterminalNode, TextIndex};
 use crate::parser::ParseError;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ParseOutput {
-    pub(crate) tree: Node,
+    pub(crate) tree: Rc<NonterminalNode>,
     pub(crate) errors: Vec<ParseError>,
 }
 
 impl ParseOutput {
-    pub fn tree(&self) -> &Node {
+    pub fn tree(&self) -> &Rc<NonterminalNode> {
         &self.tree
     }
 
@@ -22,6 +24,6 @@ impl ParseOutput {
 
     /// Creates a cursor that starts at the root of the parse tree.
     pub fn create_tree_cursor(&self) -> Cursor {
-        self.tree.clone().cursor_with_offset(TextIndex::ZERO)
+        Rc::clone(&self.tree).cursor_with_offset(TextIndex::ZERO)
     }
 }

crates/codegen/runtime/cargo/crate/src/runtime/parser/parser.rs.jinja2

@@ -108,7 +108,7 @@ impl Parser {
         {%- else -%}
             match kind {
                 {%- for parser_name, _ in model.parser.parser_functions -%}
-                    NonterminalKind::{{ parser_name }} => Self::{{ parser_name | snake_case }}.parse(self, input),
+                    NonterminalKind::{{ parser_name }} => Self::{{ parser_name | snake_case }}.parse(self, input, kind),
                 {%- endfor -%}
             }
         {%- endif -%}

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

@@ -1,6 +1,8 @@
 use std::rc::Rc;
 
-use crate::cst::{Edge, Node, TerminalKind, TerminalKindExtensions, TextIndex};
+use crate::cst::{
+    Edge, Node, NonterminalKind, NonterminalNode, TerminalKind, TerminalKindExtensions, TextIndex,
+};
 use crate::parser::lexer::Lexer;
 use crate::parser::parser_support::context::ParserContext;
 use crate::parser::parser_support::parser_result::{
@@ -12,7 +14,7 @@ pub trait ParserFunction<P>
 where
     Self: Fn(&P, &mut ParserContext<'_>) -> ParserResult,
 {
-    fn parse(&self, parser: &P, input: &str) -> ParseOutput;
+    fn parse(&self, parser: &P, input: &str, expected: NonterminalKind) -> ParseOutput;
 }
 
 impl<P, F> ParserFunction<P> for F
@@ -21,7 +23,7 @@ where
     F: Fn(&P, &mut ParserContext<'_>) -> ParserResult,
 {
     #[allow(clippy::too_many_lines)]
-    fn parse(&self, parser: &P, input: &str) -> ParseOutput {
+    fn parse(&self, parser: &P, input: &str, expected: NonterminalKind) -> ParseOutput {
         let mut stream = ParserContext::new(input);
         let mut result = self(parser, &mut stream);
 
@@ -46,7 +48,7 @@ where
                 let mut new_children = nonterminal.children.clone();
                 new_children.extend(eof_trivia);
 
-                topmost.node = Node::nonterminal(nonterminal.kind, new_children);
+                topmost.node = Node::nonterminal(expected, new_children);
             }
         }
 
@@ -85,14 +87,9 @@ where
                     TerminalKind::UNRECOGNIZED
                 };
                 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));
-                    Node::nonterminal(no_match.kind.unwrap(), trivia_nodes)
-                };
+                trivia_nodes.push(Edge::anonymous(node));
                 ParseOutput {
-                    tree,
+                    tree: Rc::new(NonterminalNode::new(expected, trivia_nodes)),
                     errors: vec![ParseError::new(
                         start..start + input.into(),
                         no_match.expected_terminals,
@@ -156,17 +153,17 @@ where
                     ));
 
                     ParseOutput {
-                        tree: Node::nonterminal(topmost_node.kind, new_children),
+                        tree: Rc::new(NonterminalNode::new(topmost_node.kind, new_children)),
                         errors,
                     }
                 } else {
-                    let tree = Node::Nonterminal(topmost_node);
+                    let tree = topmost_node;
                     let errors = stream.into_errors();
 
                     // Sanity check: Make sure that succesful parse is equivalent to not having any invalid nodes
                     debug_assert_eq!(
                         errors.is_empty(),
-                        tree.clone()
+                        Rc::clone(&tree)
                             .cursor_with_offset(TextIndex::ZERO)
                             .remaining_nodes()
                             .all(|edge| edge

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

@@ -16,7 +16,6 @@ pub enum ParserResult {
 impl Default for ParserResult {
     fn default() -> Self {
         Self::NoMatch(NoMatch {
-            kind: None,
             expected_terminals: vec![],
         })
     }
@@ -35,13 +34,13 @@ impl ParserResult {
         ParserResult::IncompleteMatch(IncompleteMatch::new(nodes, expected_terminals))
     }
 
-    /// Whenever a parser didn't run because it's disabled due to versioning. Shorthand for `no_match(None, vec![])`.
+    /// Whenever a parser didn't run because it's disabled due to versioning. Shorthand for `no_match(vec![])`.
     pub fn disabled() -> Self {
-        Self::no_match(None, vec![])
+        Self::no_match(vec![])
     }
 
-    pub fn no_match(kind: Option<NonterminalKind>, expected_terminals: Vec<TerminalKind>) -> Self {
-        ParserResult::NoMatch(NoMatch::new(kind, expected_terminals))
+    pub fn no_match(expected_terminals: Vec<TerminalKind>) -> Self {
+        ParserResult::NoMatch(NoMatch::new(expected_terminals))
     }
 
     #[must_use]
@@ -62,9 +61,7 @@ impl ParserResult {
                 nodes: vec![Edge::anonymous(Node::nonterminal(new_kind, skipped.nodes))],
                 ..skipped
             }),
-            ParserResult::NoMatch(no_match) => {
-                ParserResult::no_match(Some(new_kind), no_match.expected_terminals)
-            }
+            ParserResult::NoMatch(no_match) => ParserResult::no_match(no_match.expected_terminals),
             ParserResult::PrattOperatorMatch(_) => {
                 unreachable!("PrattOperatorMatch cannot be converted to a nonterminal")
             }
@@ -243,18 +240,13 @@ impl IncompleteMatch {
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct NoMatch {
-    /// The nonterminal kind this match is coming from
-    pub kind: Option<NonterminalKind>,
     /// Terminals that would have allowed for more progress. Collected for the purposes of error reporting.
     pub expected_terminals: Vec<TerminalKind>,
 }
 
 impl NoMatch {
-    pub fn new(kind: Option<NonterminalKind>, expected_terminals: Vec<TerminalKind>) -> Self {
-        Self {
-            kind,
-            expected_terminals,
-        }
+    pub fn new(expected_terminals: Vec<TerminalKind>) -> Self {
+        Self { expected_terminals }
     }
 }
 

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

@@ -105,7 +105,7 @@ impl ParserResult {
                 ParseResultKind::Incomplete => {
                     ParserResult::incomplete_match(nodes, expected_terminals)
                 }
-                ParseResultKind::NoMatch => ParserResult::no_match(None, expected_terminals),
+                ParseResultKind::NoMatch => ParserResult::no_match(expected_terminals),
             }
         }
     }

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

@@ -26,10 +26,7 @@ impl<const MIN_COUNT: usize> RepetitionHelper<MIN_COUNT> {
 
             // Couldn't get a full match but we allow 0 items - return an empty match
             // so the parse is considered valid but note the expected terminals
-            ParserResult::NoMatch(NoMatch {
-                kind: _,
-                expected_terminals,
-            }) if MIN_COUNT == 0 => {
+            ParserResult::NoMatch(NoMatch { expected_terminals }) if MIN_COUNT == 0 => {
                 return ParserResult::r#match(vec![], expected_terminals);
             }
             // Don't try repeating if we don't have a full match and we require at least one
@@ -63,9 +60,7 @@ impl<const MIN_COUNT: usize> RepetitionHelper<MIN_COUNT> {
                     ParserResult::IncompleteMatch(IncompleteMatch {
                         expected_terminals, ..
                     })
-                    | ParserResult::NoMatch(NoMatch {
-                        expected_terminals, ..
-                    }),
+                    | ParserResult::NoMatch(NoMatch { expected_terminals }),
                 ) => {
                     input.rewind(save);
                     running.expected_terminals = expected_terminals;

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

@@ -89,7 +89,7 @@ impl SeparatedHelper {
                 }
                 ParserResult::NoMatch(no_match) => {
                     return if accum.is_empty() {
-                        ParserResult::no_match(None, no_match.expected_terminals)
+                        ParserResult::no_match(no_match.expected_terminals)
                     } else {
                         ParserResult::incomplete_match(accum, no_match.expected_terminals)
                     };

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

@@ -1,5 +1,5 @@
 interface parser {
-    use cst.{cursor, node, nonterminal-kind, text-range};
+    use cst.{cursor, nonterminal-node, nonterminal-kind, text-range};
 
     /// A parser instance that can parse source code into syntax trees.
     /// Each parser is configured for a specific language version and grammar.
@@ -32,7 +32,7 @@ interface parser {
     resource parse-output {
         /// Returns the root node of the parsed syntax tree.
         /// Even if there are parsing errors, a partial tree will still be available.
-        tree: func() -> node;
+        tree: func() -> nonterminal-node;
 
         /// Returns a list of all parsing errors encountered.
         /// An empty list indicates successful parsing with no errors.

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

@@ -1,8 +1,10 @@
+use std::rc::Rc;
+
 use crate::wasm_crate::utils::{define_wrapper, FromFFI, IntoFFI};
 
 mod ffi {
     pub use crate::wasm_crate::bindgen::exports::nomic_foundation::slang::cst::{
-        Cursor, Node, TextRange,
+        Cursor, NonterminalNode, TextRange,
     };
     pub use crate::wasm_crate::bindgen::exports::nomic_foundation::slang::parser::{
         Guest, GuestParseError, GuestParseOutput, GuestParser, NonterminalKind, ParseError,
@@ -70,8 +72,8 @@ define_wrapper! { ParseError {
 //================================================
 
 define_wrapper! { ParseOutput {
-    fn tree(&self) -> ffi::Node {
-        self._borrow_ffi().tree().clone()._into_ffi()
+    fn tree(&self) -> ffi::NonterminalNode {
+        Rc::clone(self._borrow_ffi().tree())._into_ffi()
     }
 
     fn errors(&self) -> Vec<ffi::ParseError> {

crates/metaslang/cst/src/nodes.rs

@@ -64,6 +64,18 @@ pub struct Edge<T: KindTypes> {
     pub node: Node<T>,
 }
 
+impl<T: KindTypes> NonterminalNode<T> {
+    pub fn new(kind: T::NonterminalKind, children: Vec<Edge<T>>) -> Self {
+        let text_len = children.iter().map(|edge| edge.text_len()).sum();
+
+        NonterminalNode {
+            kind,
+            text_len,
+            children,
+        }
+    }
+}
+
 impl<T: KindTypes> Edge<T> {
     /// Creates an anonymous node (without a label).
     pub fn anonymous(node: Node<T>) -> Self {
@@ -81,13 +93,7 @@ impl<T: KindTypes> std::ops::Deref for Edge<T> {
 
 impl<T: KindTypes> Node<T> {
     pub fn nonterminal(kind: T::NonterminalKind, children: Vec<Edge<T>>) -> Self {
-        let text_len = children.iter().map(|edge| edge.text_len()).sum();
-
-        Self::Nonterminal(Rc::new(NonterminalNode {
-            kind,
-            text_len,
-            children,
-        }))
+        Self::Nonterminal(Rc::new(NonterminalNode::new(kind, children)))
     }
 
     pub fn terminal(kind: T::TerminalKind, text: String) -> Self {

crates/solidity/outputs/cargo/crate/src/extensions/bindings/mod.rs

@@ -16,7 +16,8 @@ pub fn add_built_ins(
     let parser = Parser::create(version)?;
     let parse_output = parser.parse(Parser::ROOT_KIND, source);
 
-    let built_ins_cursor = transform(parse_output.tree()).cursor_with_offset(TextIndex::ZERO);
+    let built_ins_cursor = transform(&Node::Nonterminal(Rc::clone(parse_output.tree())))
+        .cursor_with_offset(TextIndex::ZERO);
 
     binding_graph.add_system_file("built_ins.sol", built_ins_cursor);
     Ok(())