tests: fix CheckErrors::NoSuchContract error in tests

Author: csgui

Cargo.lock

@@ -35,6 +35,7 @@ rstest_reuse = { version = "0.5.0", optional = true }
 wasmtime = { version = "15.0.0", optional = true }
 hashbrown = { workspace = true, features = ["serde"] }
 getrandom = { version = "0.2", features = ["js"], optional = true}
+ouroboros = "0.18.5"
 
 [dependencies.serde_json]
 version = "1.0"
@@ -45,7 +46,6 @@ workspace = true
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 optional = true
 
-
 [dev-dependencies]
 assert-json-diff = "1.0.0"
 rstest = { version = "0.17.0" }

clarity/Cargo.toml

@@ -45,6 +45,8 @@ use crate::vm::errors::{
 };
 use crate::vm::events::*;
 use crate::vm::representations::{ClarityName, SymbolicExpression};
+#[cfg(all(feature = "clarity-wasm", feature = "testing"))]
+use crate::vm::tests::clarity_wasm::MemoryAnalysisDatabase;
 use crate::vm::types::signatures::FunctionSignature;
 use crate::vm::types::{
     AssetIdentifier, BuffData, CallableData, PrincipalData, QualifiedContractIdentifier,
@@ -219,6 +221,8 @@ pub struct GlobalContext<'a> {
     pub execution_time_tracker: ExecutionTimeTracker,
     #[cfg(feature = "clarity-wasm")]
     pub engine: Engine,
+    #[cfg(all(feature = "clarity-wasm", feature = "testing"))]
+    pub analysis_db: MemoryAnalysisDatabase,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -1341,8 +1345,6 @@ impl<'a, 'b> Environment<'a, 'b> {
         contract_content: &str,
         ast_rules: ASTRules,
     ) -> Result<()> {
-        use super::database::MemoryBackingStore;
-
         let clarity_version = self.contract_context.clarity_version;
 
         let mut contract_ast = ast::build_ast_with_rules(
@@ -1354,18 +1356,22 @@ impl<'a, 'b> Environment<'a, 'b> {
             ast_rules,
         )?;
 
-        let mut store = MemoryBackingStore::new();
-        let contract_analysis = analysis::run_analysis(
-            &contract_identifier,
-            &contract_ast.expressions,
-            &mut store.as_analysis_db(),
-            false,
-            LimitedCostTracker::Free,
-            self.global_context.epoch_id,
-            clarity_version,
-            true,
-        )
-        .map_err(|(check_error, _)| check_error.err)?;
+        let contract_analysis =
+            self.global_context
+                .analysis_db
+                .with_analysis_db_mut(|analysis_db| {
+                    analysis::run_analysis(
+                        &contract_identifier,
+                        &contract_ast.expressions,
+                        analysis_db,
+                        true,
+                        LimitedCostTracker::Free,
+                        self.global_context.epoch_id,
+                        clarity_version,
+                        true,
+                    )
+                    .map_err(|(check_error, _)| check_error.err)
+                })?;
 
         self.initialize_contract_from_ast(
             contract_identifier,
@@ -1683,6 +1689,8 @@ impl<'a> GlobalContext<'a> {
             execution_time_tracker: ExecutionTimeTracker::NoTracking,
             #[cfg(feature = "clarity-wasm")]
             engine,
+            #[cfg(all(feature = "clarity-wasm", feature = "testing"))]
+            analysis_db: MemoryAnalysisDatabase::build(),
         }
     }
 
@@ -1804,6 +1812,7 @@ impl<'a> GlobalContext<'a> {
         self.database.begin();
         let read_only = self.is_read_only();
         self.read_only.push(read_only);
+        self.analysis_db.begin();
     }
 
     pub fn begin_read_only(&mut self) {

clarity/src/vm/contexts.rs

@@ -193,7 +193,7 @@ impl fmt::Display for WasmError {
 #[cfg(feature = "clarity-wasm")]
 impl std::error::Error for WasmError {}
 
-pub type InterpreterResult<R> = Result<R, Error>;
+pub type InterpreterResult<R, E = Error> = Result<R, E>;
 
 impl<T> PartialEq<IncomparableError<T>> for IncomparableError<T> {
     fn eq(&self, _other: &IncomparableError<T>) -> bool {

clarity/src/vm/errors.rs

@@ -0,0 +1,36 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use ouroboros::self_referencing;
+use stacks_common::types::StacksEpochId;
+
+use crate::vm::analysis::{AnalysisDatabase, CheckResult, ContractAnalysis};
+use crate::vm::database::MemoryBackingStore;
+use crate::vm::errors::CheckErrors;
+use crate::vm::types::{
+    FunctionSignature, FunctionType, QualifiedContractIdentifier, TraitIdentifier,
+};
+use crate::vm::{ClarityName, ClarityVersion};
+
+#[self_referencing]
+pub struct MemoryAnalysisDatabase {
+    mem_store: MemoryBackingStore,
+    #[not_covariant]
+    #[borrows(mut mem_store)]
+    pub analysis_db: AnalysisDatabase<'this>,
+}
+
+impl MemoryAnalysisDatabase {
+    pub fn build() -> Self {
+        let mem_store = MemoryBackingStore::new();
+
+        MemoryAnalysisDatabaseBuilder {
+            mem_store,
+            analysis_db_builder: |mem_store| AnalysisDatabase::new(mem_store),
+        }
+        .build()
+    }
+
+    pub fn begin(&mut self) {
+        self.with_analysis_db_mut(|db| db.begin())
+    }
+}

clarity/src/vm/tests/clarity_wasm/mod.rs

@@ -37,6 +37,8 @@ mod sequences;
 mod simple_apply_eval;
 mod traits;
 mod variables;
+// Module to wrap code related to clarity-wasm tests
+pub mod clarity_wasm;
 
 #[cfg(any(test, feature = "testing"))]
 impl<'a> OwnedEnvironment<'a> {