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/parse_output.rs

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

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

@@ -89,7 +89,7 @@ where
                 let node = Node::terminal(kind, input.to_string());
                 trivia_nodes.push(Edge::anonymous(node));
                 ParseOutput {
-                    parse_tree: Rc::new(NonterminalNode::new(expected, trivia_nodes)),
+                    tree: Rc::new(NonterminalNode::new(expected, trivia_nodes)),
                     errors: vec![ParseError::new(
                         start..start + input.into(),
                         no_match.expected_terminals,
@@ -153,17 +153,17 @@ where
                     ));
 
                     ParseOutput {
-                        parse_tree: Rc::new(NonterminalNode::new(topmost_node.kind, new_children)),
+                        tree: Rc::new(NonterminalNode::new(topmost_node.kind, new_children)),
                         errors,
                     }
                 } else {
-                    let parse_tree = 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(),
-                        Rc::clone(&parse_tree)
+                        Rc::clone(&tree)
                             .cursor_with_offset(TextIndex::ZERO)
                             .remaining_nodes()
                             .all(|edge| edge

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

@@ -3,7 +3,7 @@ use std::rc::Rc;
 use crate::wasm_crate::utils::{define_wrapper, FromFFI, IntoFFI};
 
 mod ffi {
-    pub use crate::wasm_crate::bindings::exports::nomic_foundation::slang::cst::{
+    pub use crate::wasm_crate::bindgen::exports::nomic_foundation::slang::cst::{
         Cursor, NonterminalNode, TextRange,
     };
     pub use crate::wasm_crate::bindgen::exports::nomic_foundation::slang::parser::{

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(())

crates/solidity/outputs/cargo/tests/src/bindings.rs

@@ -1,30 +1,10 @@
-use std::rc::Rc;
-use std::sync::Arc;
-
-use anyhow::Result;
-use semver::Version;
-use slang_solidity::bindings::{self, Bindings};
-use slang_solidity::cst::{Node, TextIndex};
-use slang_solidity::parser::Parser;
-use slang_solidity::transform_built_ins_node;
-
-use crate::resolver::TestsPathResolver;
-
-pub fn create_bindings(version: &Version) -> Result<Bindings> {
-    let parser = Parser::create(version.clone())?;
-    let mut bindings =
-        bindings::create_with_resolver(version.clone(), Arc::new(TestsPathResolver {}));
-
-    let built_ins_parse_output = parser.parse(Parser::ROOT_KIND, bindings::get_built_ins(version));
-    assert!(
-        built_ins_parse_output.is_valid(),
-        "built-ins parse without errors"
-    );
-
-    let built_ins_cursor =
-        transform_built_ins_node(&Node::Nonterminal(Rc::clone(built_ins_parse_output.tree())))
-            .cursor_with_offset(TextIndex::ZERO);
-
-    bindings.add_system_file("built_ins.sol", built_ins_cursor);
-    Ok(bindings)
+use slang_solidity::bindings::{BindingGraph, Definition};
+
+pub fn lookup_definition_by_name<'a>(
+    binding_graph: &'a BindingGraph,
+    name: &str,
+) -> Option<Definition<'a>> {
+    binding_graph
+        .all_definitions()
+        .find(|definition| definition.get_cursor().node().unparse() == name)
 }

crates/solidity/testing/sanctuary/src/tests.rs

@@ -1,15 +1,15 @@
 use std::cmp::min;
 use std::path::Path;
 use std::rc::Rc;
-use std::sync::Arc;
 
 use anyhow::Result;
 use infra_utils::paths::PathExtensions;
 use itertools::Itertools;
 use metaslang_bindings::PathResolver;
 use semver::Version;
-use slang_solidity::bindings::Bindings;
-use slang_solidity::cst::{Cursor, Node, NonterminalKind, TextIndex, TextRange};
+use slang_solidity::bindings;
+use slang_solidity::bindings::BindingGraph;
+use slang_solidity::cst::{Cursor, KindTypes, NonterminalKind, TextRange};
 use slang_solidity::diagnostic::{Diagnostic, Severity};
 use slang_solidity::parser::{ParseOutput, Parser};
 use slang_solidity::utils::LanguageFacts;
@@ -215,15 +215,7 @@ fn create_bindings(
         Rc::new(SingleFileResolver {
             source_id: source_id.into(),
         }),
-    );
-    let parser = Parser::create(version.clone())?;
-    let built_ins_output = parser.parse(
-        NonterminalKind::SourceUnit,
-        bindings::get_built_ins(version),
-    );
-    let built_ins_tree = built_ins_output.tree();
-    let built_ins_cursor = transform_built_ins_node(&Node::Nonterminal(Rc::clone(built_ins_tree)))
-        .cursor_with_offset(TextIndex::ZERO);
+    )?;
 
     binding_graph.add_user_file(source_id, output.create_tree_cursor());