Adding built-ins to bindings is no longer done by default

The user must parse and add them explicitly.

crates/codegen/runtime/cargo/src/runtime/bindings/mod.rs

@@ -7,36 +7,26 @@ mod built_ins;
 use std::sync::Arc;
 
 use metaslang_bindings::{self, PathResolver};
+use semver::Version;
 
 use crate::cst::KindTypes;
-use crate::parser::Parser;
 
 pub type Bindings = metaslang_bindings::Bindings<KindTypes>;
 pub type Definition<'a> = metaslang_bindings::Definition<'a, KindTypes>;
 pub type Reference<'a> = metaslang_bindings::Reference<'a, KindTypes>;
 
 pub fn create_with_resolver(
-    parser: &Parser,
+    version: Version,
     resolver: Arc<dyn PathResolver + Sync + Send>,
 ) -> Bindings {
-    let version = parser.version.clone();
-    let built_ins_parse_output = parser.parse(Parser::ROOT_KIND, built_ins::get_contents(&version));
-    assert!(
-        built_ins_parse_output.is_valid(),
-        "built-ins parse without errors"
-    );
-
-    let mut bindings = Bindings::create(version, binding_rules::BINDING_RULES_SOURCE, resolver);
-    bindings.add_built_ins(built_ins_parse_output.create_tree_cursor());
-    bindings
+    Bindings::create(version, binding_rules::BINDING_RULES_SOURCE, resolver)
 }
 
 #[cfg(feature = "__private_testing_utils")]
 pub fn get_binding_rules() -> &'static str {
     binding_rules::BINDING_RULES_SOURCE
 }
 
-#[cfg(feature = "__private_testing_utils")]
 pub fn get_built_ins(version: &semver::Version) -> &'static str {
     built_ins::get_contents(version)
 }

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

@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use semver::Version;
+use slang_solidity::bindings::{self, Bindings};
+use slang_solidity::parser::Parser;
+
+use crate::resolver::TestsPathResolver;
+
+pub fn create_bindings(version: &Version) -> Result<Bindings> {
+    let parser = Parser::new(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"
+    );
+    bindings.add_built_ins(built_ins_parse_output.create_tree_cursor());
+    Ok(bindings)
+}

crates/solidity/outputs/cargo/tests/src/bindings_assertions/runner.rs

@@ -1,18 +1,17 @@
 use std::fs;
-use std::sync::Arc;
 
 use anyhow::Result;
 use infra_utils::cargo::CargoWorkspace;
 use semver::Version;
+use slang_solidity::diagnostic;
 use slang_solidity::parser::Parser;
-use slang_solidity::{bindings, diagnostic};
 
+use crate::bindings::create_bindings;
 use crate::bindings_assertions::assertions::{
     check_assertions, collect_assertions_into, Assertions,
 };
 use crate::generated::VERSION_BREAKS;
 use crate::multi_part_file::{split_multi_file, Part};
-use crate::resolver::TestsPathResolver;
 
 pub fn run(group_name: &str, test_name: &str) -> Result<()> {
     let file_name = format!("{test_name}.sol");
@@ -30,7 +29,8 @@ pub fn run(group_name: &str, test_name: &str) -> Result<()> {
 
 fn check_assertions_with_version(version: &Version, contents: &str) -> Result<()> {
     let parser = Parser::new(version.clone())?;
-    let mut bindings = bindings::create_with_resolver(&parser, Arc::new(TestsPathResolver {}));
+    let mut bindings = create_bindings(version)?;
+
     let mut assertions = Assertions::new();
     let mut skipped = 0;
 

crates/solidity/outputs/cargo/tests/src/bindings_output/runner.rs

@@ -1,21 +1,18 @@
-use std::sync::Arc;
-
 use anyhow::Result;
 use infra_utils::cargo::CargoWorkspace;
 use infra_utils::codegen::CodegenFileSystem;
 use infra_utils::github::GitHub;
 use infra_utils::paths::PathExtensions;
 use metaslang_graph_builder::graph::Graph;
-use slang_solidity::bindings;
 use slang_solidity::cst::KindTypes;
 use slang_solidity::parser::{ParseOutput, Parser};
 
 use super::graph::graphviz::render as render_graphviz_graph;
 use super::graph::mermaid::render as render_mermaid_graph;
 use super::renderer::render_bindings;
+use crate::bindings::create_bindings;
 use crate::generated::VERSION_BREAKS;
 use crate::multi_part_file::{split_multi_file, Part};
-use crate::resolver::TestsPathResolver;
 
 pub(crate) struct ParsedPart<'a> {
     pub path: &'a str,
@@ -40,7 +37,7 @@ pub fn run(group_name: &str, test_name: &str) -> Result<()> {
 
     for version in &VERSION_BREAKS {
         let parser = Parser::new(version.clone())?;
-        let mut bindings = bindings::create_with_resolver(&parser, Arc::new(TestsPathResolver {}));
+        let mut bindings = create_bindings(version)?;
 
         let mut parsed_parts: Vec<ParsedPart<'_>> = Vec::new();
         let multi_part = split_multi_file(&contents);

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

@@ -3,6 +3,7 @@
 use metaslang_bindings as _;
 
 mod binding_rules;
+mod bindings;
 mod bindings_assertions;
 mod bindings_output;
 mod built_ins;

crates/solidity/testing/perf/benches/iai/main.rs

@@ -36,9 +36,14 @@ fn query(files: Vec<ParsedFile>) {
     black_box(tests::query::run(&files));
 }
 
+#[library_benchmark]
+fn bindings() {
+    black_box(tests::bindings::run());
+}
+
 #[library_benchmark(setup = tests::definitions::setup)]
-fn definitions(files: Vec<ParsedFile>) {
-    black_box(tests::definitions::run(&files));
+fn definitions(dependencies: tests::definitions::Dependencies) {
+    black_box(tests::definitions::run(dependencies));
 }
 
 #[library_benchmark(setup = tests::references::setup)]
@@ -49,7 +54,7 @@ fn references(bindings: Bindings) {
 library_benchmark_group!(
     name = benchmarks;
 
-    benchmarks = parser, cursor, query, definitions, references
+    benchmarks = parser, cursor, query, bindings, definitions, references
 );
 
 main!(

crates/solidity/testing/perf/benches/iai/tests/bindings.rs

@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use metaslang_bindings::PathResolver;
+use slang_solidity::bindings::{create_with_resolver, get_built_ins, Bindings};
+use slang_solidity::parser::Parser;
+
+use crate::dataset::SOLC_VERSION;
+
+pub fn run() -> Bindings {
+    let parser = Parser::new(SOLC_VERSION).unwrap();
+    let mut bindings = create_with_resolver(SOLC_VERSION, Arc::new(NoOpResolver {}));
+
+    let built_ins_parse_output = parser.parse(Parser::ROOT_KIND, get_built_ins(&SOLC_VERSION));
+    assert!(
+        built_ins_parse_output.is_valid(),
+        "built-ins parse without errors"
+    );
+    bindings.add_built_ins(built_ins_parse_output.create_tree_cursor());
+    bindings
+}
+
+struct NoOpResolver;
+
+impl PathResolver for NoOpResolver {
+    fn resolve_path(&self, _context_path: &str, path_to_resolve: &str) -> Option<String> {
+        Some(path_to_resolve.to_string())
+    }
+}

crates/solidity/testing/perf/benches/iai/tests/definitions.rs

@@ -1,29 +1,32 @@
-use std::sync::Arc;
-
-use metaslang_bindings::PathResolver;
-use slang_solidity::bindings::{create_with_resolver, Bindings};
+use slang_solidity::bindings::Bindings;
 use slang_solidity::cst::TextIndex;
-use slang_solidity::parser::Parser;
 
-use crate::dataset::SOLC_VERSION;
 use crate::tests::parser::ParsedFile;
 
-pub fn setup() -> Vec<ParsedFile> {
-    let files = super::parser::setup();
+pub struct Dependencies {
+    pub bindings: Bindings,
+    pub files: Vec<ParsedFile>,
+}
+
+pub fn setup() -> Dependencies {
+    let bindings = super::bindings::run();
+    let files = super::parser::run(super::parser::setup());
 
-    super::parser::run(files)
+    Dependencies { bindings, files }
 }
 
-pub fn run(files: &[ParsedFile]) -> Bindings {
+pub fn run(dependencies: Dependencies) -> Bindings {
     let mut definition_count = 0_usize;
-    let parser = Parser::new(SOLC_VERSION).unwrap();
-    let mut bindings = create_with_resolver(&parser, Arc::new(NoOpResolver {}));
+    let Dependencies {
+        mut bindings,
+        files,
+    } = dependencies;
 
     for ParsedFile {
         path,
         contents: _,
         tree,
-    } in files
+    } in &files
     {
         bindings.add_file(
             path.to_str().unwrap(),
@@ -40,11 +43,3 @@ pub fn run(files: &[ParsedFile]) -> Bindings {
 
     bindings
 }
-
-struct NoOpResolver;
-
-impl PathResolver for NoOpResolver {
-    fn resolve_path(&self, _context_path: &str, path_to_resolve: &str) -> Option<String> {
-        Some(path_to_resolve.to_string())
-    }
-}

crates/solidity/testing/perf/benches/iai/tests/mod.rs

@@ -1,3 +1,4 @@
+pub mod bindings;
 pub mod cursor;
 pub mod definitions;
 pub mod parser;

crates/solidity/testing/perf/benches/iai/tests/references.rs

@@ -1,9 +1,9 @@
 use slang_solidity::bindings::Bindings;
 
 pub fn setup() -> Bindings {
-    let trees = super::definitions::setup();
+    let dependencies = super::definitions::setup();
 
-    super::definitions::run(&trees)
+    super::definitions::run(dependencies)
 }
 
 pub fn run(bindings: &Bindings) {