Format comments

Cargo.lock

@@ -1644,15 +1644,6 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19d374276b40fb8bbdee95aef7c7fa6b5316ec764510eb64b8dd0e2ed0d7e7f5"
 
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.6"
@@ -2408,20 +2399,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42012b0f064e01aa58b545fe3727f90f7dd4020f4a3ea735b50344965f5a57e9"
 
-[[package]]
-name = "generator"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d18470a76cb7f8ff746cf1f7470914f900252ec36bbc40b569d74b1258446827"
-dependencies = [
- "cc",
- "cfg-if",
- "libc",
- "log",
- "rustversion",
- "windows",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -3188,19 +3165,6 @@ version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
-[[package]]
-name = "loom"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "419e0dc8046cb947daa77eb95ae174acfbddb7673b4151f56d1eed8e93fbfaca"
-dependencies = [
- "cfg-if",
- "generator",
- "scoped-tls",
- "tracing",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "lru"
 version = "0.13.0"
@@ -3283,25 +3247,6 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
-[[package]]
-name = "moka"
-version = "0.12.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9321642ca94a4282428e6ea4af8cc2ca4eac48ac7a6a4ea8f33f76d0ce70926"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "loom",
- "parking_lot",
- "portable-atomic",
- "rustc_version 0.4.1",
- "smallvec",
- "tagptr",
- "thiserror 1.0.69",
- "uuid",
-]
-
 [[package]]
 name = "native-tls"
 version = "0.2.14"
@@ -3701,12 +3646,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
 [[package]]
 name = "potential_utf"
 version = "0.1.2"
@@ -4090,8 +4029,6 @@ name = "revive-dt-common"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "moka",
- "once_cell",
  "semver 1.0.26",
  "tokio",
 ]
@@ -4487,12 +4424,6 @@ dependencies = [
  "zeroize",
 ]
 
-[[package]]
-name = "scoped-tls"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -5345,12 +5276,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "tagptr"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
-
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -5883,17 +5808,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
-[[package]]
-name = "uuid"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
-dependencies = [
- "getrandom 0.3.3",
- "js-sys",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "valuable"
 version = "0.1.1"
@@ -6155,28 +6069,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows"
-version = "0.61.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
-dependencies = [
- "windows-collections",
- "windows-core",
- "windows-future",
- "windows-link",
- "windows-numerics",
-]
-
-[[package]]
-name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
-dependencies = [
- "windows-core",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.61.2"
@@ -6190,17 +6082,6 @@ dependencies = [
  "windows-strings 0.4.2",
 ]
 
-[[package]]
-name = "windows-future"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
-dependencies = [
- "windows-core",
- "windows-link",
- "windows-threading",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.60.0"
@@ -6225,19 +6106,9 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.3"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
-
-[[package]]
-name = "windows-numerics"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
-dependencies = [
- "windows-core",
- "windows-link",
-]
 
 [[package]]
 name = "windows-registry"
@@ -6327,15 +6198,6 @@ dependencies = [
  "windows_x86_64_msvc 0.53.0",
 ]
 
-[[package]]
-name = "windows-threading"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"

Cargo.toml

@@ -29,7 +29,6 @@ clap = { version = "4", features = ["derive"] }
 foundry-compilers-artifacts = { version = "0.18.0" }
 futures = { version = "0.3.31" }
 hex = "0.4.3"
-moka = "0.12.10"
 reqwest = { version = "0.12.15", features = ["json"] }
 once_cell = "1.21"
 semver = { version = "1.0", features = ["serde"] }

crates/common/Cargo.toml

@@ -10,7 +10,5 @@ rust-version.workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-moka = { workspace = true, features = ["sync"] }
-once_cell = { workspace = true }
 semver = { workspace = true }
 tokio = { workspace = true, default-features = false, features = ["time"] }

crates/common/src/cached_fs/mod.rs

@@ -1,73 +0,0 @@
-//! This module implements a cached file system allowing for results to be stored in-memory rather
-//! rather being queried from the file system again.
-
-use std::fs;
-use std::io::{Error, Result};
-use std::path::{Path, PathBuf};
-
-use moka::sync::Cache;
-use once_cell::sync::Lazy;
-
-pub fn read(path: impl AsRef<Path>) -> Result<Vec<u8>> {
-    static READ_CACHE: Lazy<Cache<PathBuf, Vec<u8>>> = Lazy::new(|| Cache::new(10_000));
-
-    let path = path.as_ref().canonicalize()?;
-    match READ_CACHE.get(path.as_path()) {
-        Some(content) => Ok(content),
-        None => {
-            let content = fs::read(path.as_path())?;
-            READ_CACHE.insert(path, content.clone());
-            Ok(content)
-        }
-    }
-}
-
-pub fn read_to_string(path: impl AsRef<Path>) -> Result<String> {
-    let content = read(path)?;
-    String::from_utf8(content).map_err(|_| {
-        Error::new(
-            std::io::ErrorKind::InvalidData,
-            "The contents of the file are not valid UTF8",
-        )
-    })
-}
-
-pub fn read_dir(path: impl AsRef<Path>) -> Result<Box<dyn Iterator<Item = Result<PathBuf>>>> {
-    static READ_DIR_CACHE: Lazy<Cache<PathBuf, Vec<PathBuf>>> = Lazy::new(|| Cache::new(10_000));
-
-    let path = path.as_ref().canonicalize()?;
-    match READ_DIR_CACHE.get(path.as_path()) {
-        Some(entries) => Ok(Box::new(entries.into_iter().map(Ok)) as Box<_>),
-        None => {
-            let entries = fs::read_dir(path.as_path())?
-                .flat_map(|maybe_entry| maybe_entry.map(|entry| entry.path()))
-                .collect();
-            READ_DIR_CACHE.insert(path.clone(), entries);
-            Ok(read_dir(path).unwrap())
-        }
-    }
-}
-
-pub trait PathExt {
-    fn cached_canonicalize(&self) -> Result<PathBuf>;
-}
-
-impl<T> PathExt for T
-where
-    T: AsRef<Path>,
-{
-    fn cached_canonicalize(&self) -> Result<PathBuf> {
-        static CANONICALIZATION_CACHE: Lazy<Cache<PathBuf, PathBuf>> =
-            Lazy::new(|| Cache::new(10_000));
-
-        let path = self.as_ref().to_path_buf();
-        match CANONICALIZATION_CACHE.get(&path) {
-            Some(canonicalized) => Ok(canonicalized),
-            None => {
-                let canonicalized = path.canonicalize()?;
-                CANONICALIZATION_CACHE.insert(path, canonicalized.clone());
-                Ok(canonicalized)
-            }
-        }
-    }
-}

crates/common/src/iterators/files_with_extension_iterator.rs

@@ -19,11 +19,6 @@ pub struct FilesWithExtensionIterator {
     /// this vector then they will be returned when the [`Iterator::next`] method is called. If not
     /// then we visit one of the next directories to visit.
     files_matching_allowed_extensions: Vec<PathBuf>,
-
-    /// This option controls if the the cached file system should be used or not. This could be
-    /// better for certain cases where the entries in the directories do not change and therefore
-    /// caching can be used.
-    use_cached_fs: bool,
 }
 
 impl FilesWithExtensionIterator {
@@ -32,7 +27,6 @@ impl FilesWithExtensionIterator {
             allowed_extensions: Default::default(),
             directories_to_search: vec![root_directory.as_ref().to_path_buf()],
             files_matching_allowed_extensions: Default::default(),
-            use_cached_fs: Default::default(),
         }
     }
 
@@ -43,11 +37,6 @@ impl FilesWithExtensionIterator {
         self.allowed_extensions.insert(allowed_extension.into());
         self
     }
-
-    pub fn with_use_cached_fs(mut self, use_cached_fs: bool) -> Self {
-        self.use_cached_fs = use_cached_fs;
-        self
-    }
 }
 
 impl Iterator for FilesWithExtensionIterator {
@@ -60,19 +49,16 @@ impl Iterator for FilesWithExtensionIterator {
 
         let directory_to_search = self.directories_to_search.pop()?;
 
-        let iterator = if self.use_cached_fs {
+        // Read all of the entries in the directory. If we failed to read this dir's entires then we
-            let Ok(dir_entries) = crate::cached_fs::read_dir(directory_to_search.as_path()) else {
+        // elect to just ignore it and look in the next directory, we do that by calling the next
-                return self.next();
+        // method again on the iterator, which is an intentional decision that we made here instead
-            };
+        // of panicking.
-            Box::new(dir_entries) as Box<dyn Iterator<Item = std::io::Result<PathBuf>>>
+        let Ok(dir_entries) = std::fs::read_dir(directory_to_search) else {
-        } else {
+            return self.next();
-            let Ok(dir_entries) = std::fs::read_dir(directory_to_search) else {
-                return self.next();
-            };
-            Box::new(dir_entries.map(|maybe_entry| maybe_entry.map(|entry| entry.path()))) as Box<_>
         };
 
-        for entry_path in iterator.flatten() {
+        for entry in dir_entries.flatten() {
+            let entry_path = entry.path();
             if entry_path.is_dir() {
                 self.directories_to_search.push(entry_path)
             } else if entry_path.is_file()

crates/common/src/lib.rs

@@ -1,7 +1,6 @@
 //! This crate provides common concepts, functionality, types, macros, and more that other crates in
 //! the workspace can benefit from.
 
-pub mod cached_fs;
 pub mod fs;
 pub mod futures;
 pub mod iterators;

crates/common/src/types/version_or_requirement.rs

@@ -1,9 +1,6 @@
-use std::{fmt::Display, str::FromStr};
-
-use anyhow::{Error, bail};
 use semver::{Version, VersionReq};
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug)]
 pub enum VersionOrRequirement {
     Version(Version),
     Requirement(VersionReq),
@@ -42,26 +39,3 @@ impl TryFrom<VersionOrRequirement> for VersionReq {
         Ok(requirement)
     }
 }
-
-impl FromStr for VersionOrRequirement {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Ok(version) = Version::parse(s) {
-            Ok(Self::Version(version))
-        } else if let Ok(version_req) = VersionReq::parse(s) {
-            Ok(Self::Requirement(version_req))
-        } else {
-            bail!("Not a valid version or version requirement")
-        }
-    }
-}
-
-impl Display for VersionOrRequirement {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            VersionOrRequirement::Version(version) => version.fmt(f),
-            VersionOrRequirement::Requirement(version_req) => version_req.fmt(f),
-        }
-    }
-}

crates/compiler/src/lib.rs

@@ -5,6 +5,7 @@
 
 use std::{
     collections::HashMap,
+    fs::read_to_string,
     hash::Hash,
     path::{Path, PathBuf},
 };
@@ -15,7 +16,6 @@ use semver::Version;
 use serde::{Deserialize, Serialize};
 
 use revive_common::EVMVersion;
-use revive_dt_common::cached_fs::read_to_string;
 use revive_dt_common::types::VersionOrRequirement;
 use revive_dt_config::Arguments;
 
@@ -55,7 +55,6 @@ pub struct CompilerInput {
     pub base_path: Option<PathBuf>,
     pub sources: HashMap<PathBuf, String>,
     pub libraries: HashMap<PathBuf, HashMap<String, Address>>,
-    pub revert_string_handling: Option<RevertString>,
 }
 
 /// The generic compilation output configuration.
@@ -92,7 +91,6 @@ where
                 base_path: Default::default(),
                 sources: Default::default(),
                 libraries: Default::default(),
-                revert_string_handling: Default::default(),
             },
             additional_options: T::Options::default(),
         }
@@ -144,14 +142,6 @@ where
         self
     }
 
-    pub fn with_revert_string_handling(
-        mut self,
-        revert_string_handling: impl Into<Option<RevertString>>,
-    ) -> Self {
-        self.input.revert_string_handling = revert_string_handling.into();
-        self
-    }
-
     pub fn with_additional_options(mut self, options: impl Into<T::Options>) -> Self {
         self.additional_options = options.into();
         self
@@ -170,15 +160,3 @@ where
         self.input.clone()
     }
 }
-
-/// Defines how the compiler should handle revert strings.
-#[derive(
-    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
-)]
-pub enum RevertString {
-    #[default]
-    Default,
-    Debug,
-    Strip,
-    VerboseDebug,
-}

crates/compiler/src/revive_resolc.rs

@@ -2,7 +2,6 @@
 //! compiling contracts to PolkaVM (PVM) bytecode.
 
 use std::{
-    os::unix::process::CommandExt,
     path::PathBuf,
     process::{Command, Stdio},
 };
@@ -48,9 +47,6 @@ impl SolidityCompiler for Resolc {
             base_path,
             sources,
             libraries,
-            // TODO: this is currently not being handled since there is no way to pass it into
-            // resolc. So, we need to go back to this later once it's supported.
-            revert_string_handling: _,
         }: CompilerInput,
         additional_options: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
@@ -93,14 +89,11 @@ impl SolidityCompiler for Resolc {
         };
 
         let mut command = AsyncCommand::new(&self.resolc_path);
-        unsafe {
+        command
-            command
+            .stdin(Stdio::piped())
-                .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
-                .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
-                .stderr(Stdio::piped())
+            .arg("--standard-json");
-                .arg("--standard-json")
-                .pre_exec(|| Ok(()))
-        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -219,15 +212,12 @@ impl SolidityCompiler for Resolc {
         // Logic for parsing the resolc version from the following string:
         // Solidity frontend for the revive compiler version 0.3.0+commit.b238913.llvm-18.1.8
 
-        let output = unsafe {
+        let output = Command::new(self.resolc_path.as_path())
-            Command::new(self.resolc_path.as_path())
+            .arg("--version")
-                .arg("--version")
+            .stdout(Stdio::piped())
-                .stdout(Stdio::piped())
+            .spawn()?
-                .pre_exec(|| Ok(()))
+            .wait_with_output()?
-                .spawn()?
+            .stdout;
-                .wait_with_output()?
-                .stdout
-        };
         let output = String::from_utf8_lossy(&output);
         let version_string = output
             .split("version ")

crates/compiler/src/solc.rs

@@ -2,7 +2,6 @@
 //! compiling contracts to EVM bytecode.
 
 use std::{
-    os::unix::process::CommandExt,
     path::PathBuf,
     process::{Command, Stdio},
 };
@@ -32,7 +31,7 @@ pub struct Solc {
 impl SolidityCompiler for Solc {
     type Options = ();
 
-    #[tracing::instrument(level = "info", ret)]
+    #[tracing::instrument(level = "debug", ret)]
     async fn build(
         &self,
         CompilerInput {
@@ -43,7 +42,6 @@ impl SolidityCompiler for Solc {
             base_path,
             sources,
             libraries,
-            revert_string_handling,
         }: CompilerInput,
         _: Self::Options,
     ) -> anyhow::Result<CompilerOutput> {
@@ -89,28 +87,16 @@ impl SolidityCompiler for Solc {
                         })
                         .collect(),
                 },
-                debug: revert_string_handling.map(|revert_string_handling| DebuggingSettings {
-                    revert_strings: match revert_string_handling {
-                        crate::RevertString::Default => Some(RevertStrings::Default),
-                        crate::RevertString::Debug => Some(RevertStrings::Debug),
-                        crate::RevertString::Strip => Some(RevertStrings::Strip),
-                        crate::RevertString::VerboseDebug => Some(RevertStrings::VerboseDebug),
-                    },
-                    debug_info: Default::default(),
-                }),
                 ..Default::default()
             },
         };
 
         let mut command = AsyncCommand::new(&self.solc_path);
-        unsafe {
+        command
-            command
+            .stdin(Stdio::piped())
-                .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
-                .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
-                .stderr(Stdio::piped())
+            .arg("--standard-json");
-                .arg("--standard-json")
-                .pre_exec(|| Ok(()))
-        };
 
         if let Some(ref base_path) = base_path {
             command.arg("--base-path").arg(base_path);
@@ -124,20 +110,12 @@ impl SolidityCompiler for Solc {
                     .join(","),
             );
         }
-        let mut child = command
+        let mut child = command.spawn()?;
-            .spawn()
-            .inspect_err(|err| tracing::error!(%err, "Failed to spawn the solc command"))?;
 
         let stdin = child.stdin.as_mut().expect("should be piped");
         let serialized_input = serde_json::to_vec(&input)?;
-        stdin
+        stdin.write_all(&serialized_input).await?;
-            .write_all(&serialized_input)
+        let output = child.wait_with_output().await?;
-            .await
-            .inspect_err(|err| tracing::error!(%err, "Failed to write standard JSON to stdin"))?;
-        let output = child
-            .wait_with_output()
-            .await
-            .inspect_err(|err| tracing::error!(%err, "Failed to get the output of solc"))?;
 
         if !output.status.success() {
             let json_in = serde_json::to_string_pretty(&input)?;
@@ -174,13 +152,10 @@ impl SolidityCompiler for Solc {
 
         let mut compiler_output = CompilerOutput::default();
         for (contract_path, contracts) in parsed.contracts {
-            let map =
+            let map = compiler_output
-                compiler_output
+                .contracts
-                    .contracts
+                .entry(contract_path.canonicalize()?)
-                    .entry(contract_path.canonicalize().inspect_err(
+                .or_default();
-                        |err| tracing::error!(%err, "Canonicalization of path failed"),
-                    )?)
-                    .or_default();
             for (contract_name, contract_info) in contracts.into_iter() {
                 let source_code = contract_info
                     .evm
@@ -220,13 +195,10 @@ impl SolidityCompiler for Solc {
         // Version: 0.8.30+commit.73712a01.Darwin.appleclang
         // ```
 
-        let child = unsafe {
+        let child = Command::new(self.solc_path.as_path())
-            Command::new(self.solc_path.as_path())
+            .arg("--version")
-                .arg("--version")
+            .stdout(Stdio::piped())
-                .stdout(Stdio::piped())
+            .spawn()?;
-                .pre_exec(|| Ok(()))
-                .spawn()?
-        };
         let output = child.wait_with_output()?;
         let output = String::from_utf8_lossy(&output.stdout);
         let version_line = output

crates/config/src/lib.rs

@@ -96,19 +96,10 @@ pub struct Arguments {
     #[arg(long, default_value = "1")]
     pub number_of_nodes: usize,
 
-    /// Determines the amount of tokio worker threads that will will be used.
+    /// Determines the amount of threads that will will be used.
-    #[arg(
+    #[arg(long, default_value = "12")]
-        long,
-        default_value_t = std::thread::available_parallelism()
-            .map(|n| n.get())
-            .unwrap_or(1)
-    )]
     pub number_of_threads: usize,
 
-    /// Determines the amount of concurrent tasks that will be spawned to run tests. Defaults to 10 x the number of nodes.
-    #[arg(long)]
-    pub number_concurrent_tasks: Option<usize>,
-
     /// Extract problems back to the test corpus.
     #[arg(short, long = "extract-problems")]
     pub extract_problems: bool,
@@ -143,13 +134,6 @@ impl Arguments {
         panic!("should have a workdir configured")
     }
 
-    /// Return the number of concurrent tasks to run. This is provided via the
-    /// `--number-concurrent-tasks` argument, and otherwise defaults to --number-of-nodes * 20.
-    pub fn number_of_concurrent_tasks(&self) -> usize {
-        self.number_concurrent_tasks
-            .unwrap_or(20 * self.number_of_nodes)
-    }
-
     /// Try to parse `self.account` into a [PrivateKeySigner],
     /// panicing on error.
     pub fn wallet(&self) -> EthereumWallet {

crates/core/src/main.rs

@@ -1,6 +1,6 @@
 use std::{
     collections::HashMap,
-    path::{Path, PathBuf},
+    path::Path,
     sync::{Arc, LazyLock},
     time::Instant,
 };
@@ -18,8 +18,8 @@ use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_node_interaction::EthereumNode;
 use semver::Version;
 use temp_dir::TempDir;
-use tokio::sync::{Mutex, RwLock, mpsc};
+use tokio::sync::{Mutex, RwLock};
-use tracing::{Instrument, Level, instrument};
+use tracing::{Instrument, Level};
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 use revive_dt_compiler::SolidityCompiler;
@@ -34,35 +34,22 @@ use revive_dt_format::{
     corpus::Corpus,
     input::{Input, Step},
     metadata::{ContractInstance, ContractPathAndIdent, Metadata, MetadataFile},
-    mode::{Mode, SolcMode},
+    mode::SolcMode,
 };
 use revive_dt_node::pool::NodePool;
 use revive_dt_report::reporter::{Report, Span};
 
 static TEMP_DIR: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
 
-type CompilationCache = Arc<
+type CompilationCache<'a> = Arc<
     RwLock<
         HashMap<
-            (PathBuf, SolcMode, TestingPlatform),
+            (&'a Path, SolcMode, TestingPlatform),
             Arc<Mutex<Option<Arc<(Version, CompilerOutput)>>>>,
         >,
     >,
 >;
 
-/// this represents a single "test"; a mode, path and collection of cases.
-#[derive(Clone)]
-struct Test {
-    metadata: Metadata,
-    path: PathBuf,
-    mode: SolcMode,
-    case_idx: usize,
-    case: Case,
-}
-
-/// This represents the results that we gather from running test cases.
-type CaseResult = Result<usize, anyhow::Error>;
-
 fn main() -> anyhow::Result<()> {
     let args = init_cli()?;
 
@@ -133,7 +120,7 @@ fn collect_corpora(args: &Arguments) -> anyhow::Result<HashMap<Corpus, Vec<Metad
 
 async fn run_driver<L, F>(
     args: &Arguments,
-    metadata_files: &[MetadataFile],
+    tests: &[MetadataFile],
     span: Span,
 ) -> anyhow::Result<()>
 where
@@ -142,25 +129,10 @@ where
     L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
     F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
 {
-    let (report_tx, report_rx) = mpsc::unbounded_channel::<(Test, CaseResult)>();
+    let leader_nodes = NodePool::<L::Blockchain>::new(args)?;
+    let follower_nodes = NodePool::<F::Blockchain>::new(args)?;
 
-    let tests = prepare_tests::<L, F>(metadata_files);
+    let test_cases = tests
-    let driver_task = start_driver_task::<L, F>(args, tests, span, report_tx)?;
-    let status_reporter_task = start_reporter_task(report_rx);
-
-    tokio::join!(status_reporter_task, driver_task);
-
-    Ok(())
-}
-
-fn prepare_tests<L, F>(metadata_files: &[MetadataFile]) -> impl Iterator<Item = Test>
-where
-    L: Platform,
-    F: Platform,
-    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-{
-    metadata_files
         .iter()
         .flat_map(
             |MetadataFile {
@@ -172,7 +144,8 @@ where
                     .iter()
                     .enumerate()
                     .flat_map(move |(case_idx, case)| {
-                        SolcMode::ALL
+                        metadata
+                            .solc_modes()
                             .into_iter()
                             .map(move |solc_mode| (path, metadata, case_idx, case, solc_mode))
                     })
@@ -225,180 +198,188 @@ where
             }
             None => true,
         })
-        .flat_map(|(path, metadata, case_idx, case, solc_mode)| {
+        .collect::<Vec<_>>();
-            if let Some(ref case_modes) = case.modes {
+
-                case_modes
+    let metadata_case_status = Arc::new(RwLock::new(test_cases.iter().fold(
-                    .iter()
+        HashMap::<_, HashMap<_, _>>::new(),
-                    .filter_map(Mode::as_solc_mode)
+        |mut map, (path, _, case_idx, case, solc_mode)| {
-                    .filter(|case_mode| case_mode.matches(&solc_mode))
+            map.entry((path.to_path_buf(), solc_mode.clone()))
-                    .map(|case_mode| (path, metadata, case_idx, case, case_mode.clone()))
+                .or_default()
-                    .collect::<Vec<_>>()
+                .insert((CaseIdx::new(*case_idx), case.name.clone()), None::<bool>);
-                    .into_iter()
+            map
-            } else if let Some(ref metadata_modes) = metadata.modes {
+        },
-                metadata_modes
+    )));
-                    .iter()
+    let status_reporter_task = {
-                    .filter_map(Mode::as_solc_mode)
+        let metadata_case_status = metadata_case_status.clone();
-                    .filter(|metadata_mode| metadata_mode.matches(&solc_mode))
+        let start = Instant::now();
-                    .map(|metadata_mode| (path, metadata, case_idx, case, metadata_mode.clone()))
+        async move {
-                    .collect::<Vec<_>>()
+            const GREEN: &str = "\x1B[32m";
-                    .into_iter()
+            const RED: &str = "\x1B[31m";
-            } else {
+            const RESET: &str = "\x1B[0m";
-                vec![(path, metadata, case_idx, case, solc_mode)].into_iter()
+
-            }
+            let mut entries_to_delete = Vec::new();
-        })
+            let mut number_of_successes = 0;
-        .map(|(metadata_file_path, metadata, case_idx, case, solc_mode)| {
+            let mut number_of_failures = 0;
-            Test {
+            loop {
-                metadata: metadata.clone(),
+                let metadata_case_status_read = metadata_case_status.read().await;
-                path: metadata_file_path.to_path_buf(),
+                if metadata_case_status_read.is_empty() {
-                mode: solc_mode,
+                    break;
-                case_idx,
+                }
-                case: case.clone(),
+
-            }
+                for ((metadata_file_path, solc_mode), case_status) in
-        })
+                    metadata_case_status_read.iter()
-}
+                {
+                    if case_status.values().any(|value| value.is_none()) {
+                        continue;
+                    }
+
+                    let contains_failures = case_status
+                        .values()
+                        .any(|value| value.is_some_and(|value| !value));
+
+                    if !contains_failures {
+                        eprintln!(
+                            "{}Succeeded:{} {} - {:?}",
+                            GREEN,
+                            RESET,
+                            metadata_file_path.display(),
+                            solc_mode
+                        )
+                    } else {
+                        eprintln!(
+                            "{}Failed:{} {} - {:?}",
+                            RED,
+                            RESET,
+                            metadata_file_path.display(),
+                            solc_mode
+                        )
+                    };
+
+                    number_of_successes += case_status
+                        .values()
+                        .filter(|value| value.is_some_and(|value| value))
+                        .count();
+                    number_of_failures += case_status
+                        .values()
+                        .filter(|value| value.is_some_and(|value| !value))
+                        .count();
+
+                    let mut case_status = case_status
+                        .iter()
+                        .map(|((case_idx, case_name), case_status)| {
+                            (case_idx.into_inner(), case_name, case_status.unwrap())
+                        })
+                        .collect::<Vec<_>>();
+                    case_status.sort_by(|a, b| a.0.cmp(&b.0));
+                    for (case_idx, case_name, case_status) in case_status.into_iter() {
+                        if case_status {
+                            eprintln!(
+                                "  {GREEN}Case Succeeded:{RESET} {} - Case Idx: {case_idx}",
+                                case_name
+                                    .as_ref()
+                                    .map(|string| string.as_str())
+                                    .unwrap_or("Unnamed case")
+                            )
+                        } else {
+                            eprintln!(
+                                "  {RED}Case Failed:{RESET} {} - Case Idx: {case_idx}",
+                                case_name
+                                    .as_ref()
+                                    .map(|string| string.as_str())
+                                    .unwrap_or("Unnamed case")
+                            )
+                        };
+                    }
+                    eprintln!();
+
+                    entries_to_delete.push((metadata_file_path.clone(), solc_mode.clone()));
+                }
+
+                drop(metadata_case_status_read);
+                let mut metadata_case_status_write = metadata_case_status.write().await;
+                for entry in entries_to_delete.drain(..) {
+                    metadata_case_status_write.remove(&entry);
+                }
+
+                tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+            }
+
+            let elapsed = start.elapsed();
+            eprintln!(
+                "{GREEN}{}{RESET} cases succeeded, {RED}{}{RESET} cases failed in {} seconds",
+                number_of_successes,
+                number_of_failures,
+                elapsed.as_secs()
+            );
+        }
+    };
 
-fn start_driver_task<L, F>(
-    args: &Arguments,
-    tests: impl Iterator<Item = Test>,
-    span: Span,
-    report_tx: mpsc::UnboundedSender<(Test, CaseResult)>,
-) -> anyhow::Result<impl Future<Output = ()>>
-where
-    L: Platform,
-    F: Platform,
-    L::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-    F::Blockchain: revive_dt_node::Node + Send + Sync + 'static,
-{
-    let leader_nodes = Arc::new(NodePool::<L::Blockchain>::new(args)?);
-    let follower_nodes = Arc::new(NodePool::<F::Blockchain>::new(args)?);
     let compilation_cache = Arc::new(RwLock::new(HashMap::new()));
-    let number_concurrent_tasks = args.number_of_concurrent_tasks();
+    let driver_task = futures::stream::iter(test_cases).for_each_concurrent(
-
+        None,
-    Ok(futures::stream::iter(tests).for_each_concurrent(
+        |(metadata_file_path, metadata, case_idx, case, solc_mode)| {
-        // We want to limit the concurrent tasks here because:
-        //
-        // 1. We don't want to overwhelm the nodes with too many requests, leading to responses timing out.
-        // 2. We don't want to open too many files at once, leading to the OS running out of file descriptors.
-        //
-        // By default, we allow maximum of 10 ongoing requests per node in order to limit (1), and assume that
-        // this number will automatically be low enough to address (2). The user can override this.
-        Some(number_concurrent_tasks),
-        move |test| {
-            let leader_nodes = leader_nodes.clone();
-            let follower_nodes = follower_nodes.clone();
             let compilation_cache = compilation_cache.clone();
-            let report_tx = report_tx.clone();
+            let leader_node = leader_nodes.round_robbin();
-
+            let follower_node = follower_nodes.round_robbin();
+            let tracing_span = tracing::span!(
+                Level::INFO,
+                "Running driver",
+                metadata_file_path = %metadata_file_path.display(),
+                case_idx = case_idx,
+                solc_mode = ?solc_mode,
+            );
+            let metadata_case_status = metadata_case_status.clone();
             async move {
-                let leader_node = leader_nodes.round_robbin();
-                let follower_node = follower_nodes.round_robbin();
-
-                let tracing_span = tracing::span!(
-                    Level::INFO,
-                    "Running driver",
-                    metadata_file_path = %test.path.display(),
-                    case_idx = ?test.case_idx,
-                    solc_mode = %test.mode,
-                );
-
                 let result = handle_case_driver::<L, F>(
-                    &test.path,
+                    metadata_file_path.as_path(),
-                    &test.metadata,
+                    metadata,
-                    test.case_idx.into(),
+                    case_idx.into(),
-                    &test.case,
+                    case,
-                    test.mode.clone(),
+                    solc_mode.clone(),
                     args,
                     compilation_cache.clone(),
                     leader_node,
                     follower_node,
                     span,
                 )
-                .instrument(tracing_span)
                 .await;
-
+                let mut metadata_case_status = metadata_case_status.write().await;
-                report_tx
+                match result {
-                    .send((test, result))
+                    Ok(inputs_executed) => {
-                    .expect("Failed to send report");
+                        tracing::info!(inputs_executed, "Execution succeeded");
+                        metadata_case_status
+                            .entry((metadata_file_path.clone(), solc_mode))
+                            .or_default()
+                            .insert((CaseIdx::new(case_idx), case.name.clone()), Some(true));
+                    }
+                    Err(error) => {
+                        metadata_case_status
+                            .entry((metadata_file_path.clone(), solc_mode))
+                            .or_default()
+                            .insert((CaseIdx::new(case_idx), case.name.clone()), Some(false));
+                        tracing::error!(%error, "Execution failed")
+                    }
+                }
+                tracing::info!("Execution completed");
             }
+            .instrument(tracing_span)
         },
-    ))
-}
-
-async fn start_reporter_task(mut report_rx: mpsc::UnboundedReceiver<(Test, CaseResult)>) {
-    let start = Instant::now();
-
-    const GREEN: &str = "\x1B[32m";
-    const RED: &str = "\x1B[31m";
-    const COLOR_RESET: &str = "\x1B[0m";
-    const BOLD: &str = "\x1B[1m";
-    const BOLD_RESET: &str = "\x1B[22m";
-
-    let mut number_of_successes = 0;
-    let mut number_of_failures = 0;
-    let mut failures = vec![];
-
-    // Wait for reports to come from our test runner. When the channel closes, this ends.
-    while let Some((test, case_result)) = report_rx.recv().await {
-        let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
-        let case_idx = test.case_idx;
-        let test_path = test.path.display();
-        let test_mode = test.mode.clone();
-
-        match case_result {
-            Ok(_inputs) => {
-                number_of_successes += 1;
-                eprintln!(
-                    "{GREEN}Case Succeeded:{COLOR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
-                );
-            }
-            Err(err) => {
-                number_of_failures += 1;
-                eprintln!(
-                    "{RED}Case Failed:{COLOR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode})"
-                );
-                failures.push((test, err));
-            }
-        }
-    }
-
-    eprintln!();
-    let elapsed = start.elapsed();
-
-    // Now, log the failures with more complete errors at the bottom, like `cargo test` does, so
-    // that we don't have to scroll through the entire output to find them.
-    if !failures.is_empty() {
-        eprintln!("{BOLD}Failures:{BOLD_RESET}\n");
-
-        for failure in failures {
-            let (test, err) = failure;
-            let case_name = test.case.name.as_deref().unwrap_or("unnamed_case");
-            let case_idx = test.case_idx;
-            let test_path = test.path.display();
-            let test_mode = test.mode.clone();
-
-            eprintln!(
-                "---- {RED}Case Failed:{COLOR_RESET} {test_path} -> {case_name}:{case_idx} (mode: {test_mode}) ----\n\n{err}\n"
-            );
-        }
-    }
-
-    // Summary at the end.
-    eprintln!(
-        "{} cases: {GREEN}{number_of_successes}{COLOR_RESET} cases succeeded, {RED}{number_of_failures}{COLOR_RESET} cases failed in {} seconds",
-        number_of_successes + number_of_failures,
-        elapsed.as_secs()
     );
+
+    tokio::join!(status_reporter_task, driver_task);
+
+    Ok(())
 }
 
 #[allow(clippy::too_many_arguments)]
-async fn handle_case_driver<L, F>(
+async fn handle_case_driver<'a, L, F>(
-    metadata_file_path: &Path,
+    metadata_file_path: &'a Path,
-    metadata: &Metadata,
+    metadata: &'a Metadata,
     case_idx: CaseIdx,
     case: &Case,
     mode: SolcMode,
     config: &Arguments,
-    compilation_cache: CompilationCache,
+    compilation_cache: CompilationCache<'a>,
     leader_node: &L::Blockchain,
     follower_node: &F::Blockchain,
     _: Span,
@@ -539,9 +520,11 @@ where
         );
 
         let Some(leader_library_address) = leader_receipt.contract_address else {
+            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
         let Some(follower_library_address) = follower_receipt.contract_address else {
+            tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");
         };
 
@@ -571,16 +554,8 @@ where
         .any(|(code, _)| !code.chars().all(|char| char.is_ascii_hexdigit()));
     let (leader_compiled_contracts, follower_compiled_contracts) =
         if metadata_file_contains_libraries && compiled_contracts_require_linking {
-            let leader_key = (
+            let leader_key = (metadata_file_path, mode.clone(), L::config_id());
-                metadata_file_path.to_path_buf(),
+            let follower_key = (metadata_file_path, mode.clone(), L::config_id());
-                mode.clone(),
-                L::config_id(),
-            );
-            let follower_key = (
-                metadata_file_path.to_path_buf(),
-                mode.clone(),
-                F::config_id(),
-            );
             {
                 let mut cache = compilation_cache.write().await;
                 cache.remove(&leader_key);
@@ -634,19 +609,15 @@ where
     driver.execute().await
 }
 
-async fn get_or_build_contracts<P: Platform>(
+async fn get_or_build_contracts<'a, P: Platform>(
-    metadata: &Metadata,
+    metadata: &'a Metadata,
-    metadata_file_path: &Path,
+    metadata_file_path: &'a Path,
     mode: SolcMode,
     config: &Arguments,
-    compilation_cache: CompilationCache,
+    compilation_cache: CompilationCache<'a>,
     deployed_libraries: &HashMap<ContractInstance, (Address, JsonAbi)>,
 ) -> anyhow::Result<Arc<(Version, CompilerOutput)>> {
-    let key = (
+    let key = (metadata_file_path, mode.clone(), P::config_id());
-        metadata_file_path.to_path_buf(),
-        mode.clone(),
-        P::config_id(),
-    );
     if let Some(compilation_artifact) = compilation_cache.read().await.get(&key).cloned() {
         let mut compilation_artifact = compilation_artifact.lock().await;
         match *compilation_artifact {
@@ -694,16 +665,6 @@ async fn get_or_build_contracts<P: Platform>(
     Ok(compiled_contracts.clone())
 }
 
-#[instrument(
-    level = "info",
-    skip_all,
-    fields(
-        metadata_file_path = %metadata_file_path.display(),
-        mode = %mode,
-        deployed_libraries = deployed_libraries.len(),
-    ),
-    err
-)]
 async fn compile_contracts<P: Platform>(
     metadata: &Metadata,
     metadata_file_path: &Path,
@@ -714,25 +675,18 @@ async fn compile_contracts<P: Platform>(
     let compiler_version_or_requirement = mode.compiler_version_to_use(config.solc.clone());
     let compiler_path =
         P::Compiler::get_compiler_executable(config, compiler_version_or_requirement).await?;
-    let compiler_version = P::Compiler::new(compiler_path.clone())
+    let compiler_version = P::Compiler::new(compiler_path.clone()).version()?;
-        .version()
-        .inspect_err(|err| tracing::error!(%err, "Failed to get compiler version"))?;
 
     tracing::info!(
         %compiler_version,
         metadata_file_path = %metadata_file_path.display(),
-        mode = %mode,
+        mode = ?mode,
         "Compiling contracts"
     );
 
     let compiler = Compiler::<P::Compiler>::new()
-        .with_allow_path(
+        .with_allow_path(metadata.directory()?)
-            metadata
+        .with_optimization(mode.solc_optimize());
-                .directory()
-                .inspect_err(|err| tracing::error!(%err, "Failed to get the metadata directory"))?,
-        )
-        .with_optimization(mode.optimize)
-        .with_via_ir(mode.via_ir);
     let mut compiler = metadata
         .files_to_compile()?
         .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
@@ -749,28 +703,14 @@ async fn compile_contracts<P: Platform>(
         // yet more compute intensive route, of telling solc that all of the files need to link the
         // library and it will only perform the linking for the files that do actually need the
         // library.
-        compiler =
+        compiler = FilesWithExtensionIterator::new(metadata.directory()?)
-            FilesWithExtensionIterator::new(metadata.directory().inspect_err(
-                |err| tracing::error!(%err, "Failed to get the metadata directory"),
-            )?)
             .with_allowed_extension("sol")
-            .with_use_cached_fs(true)
             .fold(compiler, |compiler, path| {
                 compiler.with_library(&path, library_ident.as_str(), *library_address)
             });
     }
 
-    let compiler_output = compiler
+    let compiler_output = compiler.try_build(compiler_path).await?;
-        .try_build(compiler_path)
-        .await
-        .inspect_err(|err| tracing::error!(%err, "Contract compilation failed"))?;
-
-    tracing::info!(
-        %compiler_version,
-        metadata_file_path = %metadata_file_path.display(),
-        mode = %mode,
-        "Compiled contracts"
-    );
 
     Ok((compiler_version, compiler_output))
 }

crates/format/src/case.rs

@@ -1,12 +1,9 @@
-use std::collections::HashSet;
-
 use serde::{Deserialize, Serialize};
 
 use revive_dt_common::macros::define_wrapper_type;
 
 use crate::{
     input::{Expected, Step},
-    metadata::{deserialize_compilation_modes, serialize_compilation_modes},
     mode::Mode,
 };
 
@@ -18,13 +15,8 @@ pub struct Case {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comment: Option<String>,
 
-    #[serde(
+    #[serde(skip_serializing_if = "Option::is_none")]
-        default,
+    pub modes: Option<Vec<Mode>>,
-        skip_serializing_if = "Option::is_none",
-        deserialize_with = "deserialize_compilation_modes",
-        serialize_with = "serialize_compilation_modes"
-    )]
-    pub modes: Option<HashSet<Mode>>,
 
     #[serde(rename = "inputs")]
     pub steps: Vec<Step>,
@@ -40,6 +32,7 @@ pub struct Case {
 }
 
 impl Case {
+    #[allow(irrefutable_let_patterns)]
     pub fn steps_iterator(&self) -> impl Iterator<Item = Step> {
         let steps_len = self.steps.len();
         self.steps

crates/format/src/corpus.rs

@@ -3,7 +3,6 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use revive_dt_common::cached_fs::read_dir;
 use serde::{Deserialize, Serialize};
 
 use crate::metadata::MetadataFile;
@@ -55,7 +54,7 @@ impl Corpus {
 /// `path` is expected to be a directory.
 pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
     if path.is_dir() {
-        let dir_entry = match read_dir(path) {
+        let dir_entry = match std::fs::read_dir(path) {
             Ok(dir_entry) => dir_entry,
             Err(error) => {
                 tracing::error!("failed to read dir '{}': {error}", path.display());
@@ -63,8 +62,8 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
             }
         };
 
-        for path in dir_entry {
+        for entry in dir_entry {
-            let path = match path {
+            let entry = match entry {
                 Ok(entry) => entry,
                 Err(error) => {
                     tracing::error!("error reading dir entry: {error}");
@@ -72,6 +71,7 @@ pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
                 }
             };
 
+            let path = entry.path();
             if path.is_dir() {
                 collect_metadata(&path, tests);
                 continue;

crates/format/src/metadata.rs

@@ -1,19 +1,17 @@
 use std::{
     cmp::Ordering,
-    collections::{BTreeMap, HashSet},
+    collections::BTreeMap,
     fmt::Display,
-    fs::File,
+    fs::{File, read_to_string},
     ops::Deref,
     path::{Path, PathBuf},
     str::FromStr,
 };
 
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::{Deserialize, Serialize};
 
 use revive_common::EVMVersion;
-use revive_dt_common::{
+use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wrapper_type};
-    cached_fs::read_to_string, iterators::FilesWithExtensionIterator, macros::define_wrapper_type,
-};
 
 use crate::{
     case::Case,
@@ -67,13 +65,8 @@ pub struct Metadata {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub libraries: Option<BTreeMap<PathBuf, BTreeMap<ContractIdent, ContractInstance>>>,
 
-    #[serde(
+    #[serde(skip_serializing_if = "Option::is_none")]
-        default,
+    pub modes: Option<Vec<Mode>>,
-        skip_serializing_if = "Option::is_none",
-        deserialize_with = "deserialize_compilation_modes",
-        serialize_with = "serialize_compilation_modes"
-    )]
-    pub modes: Option<HashSet<Mode>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub file_path: Option<PathBuf>,
@@ -82,12 +75,6 @@ pub struct Metadata {
     /// be run of the evm version of the nodes match the evm version specified here.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub required_evm_version: Option<EvmVersionRequirement>,
-
-    /// A set of compilation directives that will be passed to the compiler whenever the contracts for
-    /// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
-    /// just a filter for when a test can run whereas this is an instruction to the compiler.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub compiler_directives: Option<CompilationDirectives>,
 }
 
 impl Metadata {
@@ -95,7 +82,7 @@ impl Metadata {
     pub fn solc_modes(&self) -> Vec<SolcMode> {
         self.modes
             .to_owned()
-            .unwrap_or_else(|| SolcMode::ALL.map(Mode::Solidity).iter().cloned().collect())
+            .unwrap_or_else(|| vec![Mode::Solidity(Default::default())])
             .iter()
             .filter_map(|mode| match mode {
                 Mode::Solidity(solc_mode) => Some(solc_mode),
@@ -266,45 +253,12 @@ impl Metadata {
             Ok(Box::new(std::iter::once(metadata_file_path.clone())))
         } else {
             Ok(Box::new(
-                FilesWithExtensionIterator::new(self.directory()?)
+                FilesWithExtensionIterator::new(self.directory()?).with_allowed_extension("sol"),
-                    .with_allowed_extension("sol")
-                    .with_use_cached_fs(true),
             ))
         }
     }
 }
 
-pub fn deserialize_compilation_modes<'de, D>(
-    deserializer: D,
-) -> Result<Option<HashSet<Mode>>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let maybe_strings = Option::<Vec<String>>::deserialize(deserializer)?;
-    Ok(maybe_strings.map(|strings| {
-        strings
-            .into_iter()
-            .flat_map(Mode::parse_from_string)
-            .collect()
-    }))
-}
-
-pub fn serialize_compilation_modes<S>(
-    value: &Option<HashSet<Mode>>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: Serializer,
-{
-    match value {
-        None => serializer.serialize_none(),
-        Some(modes) => {
-            let strings: Vec<String> = modes.iter().cloned().map(Into::<String>::into).collect();
-            serializer.serialize_some(&strings)
-        }
-    }
-}
-
 define_wrapper_type!(
     /// Represents a contract instance found a metadata file.
     ///
@@ -536,31 +490,6 @@ impl From<EvmVersionRequirement> for String {
     }
 }
 
-/// A set of compilation directives that will be passed to the compiler whenever the contracts for
-/// the test are being compiled. Note that this differs from the [`Mode`]s in that a [`Mode`] is
-/// just a filter for when a test can run whereas this is an instruction to the compiler.
-/// Defines how the compiler should handle revert strings.
-#[derive(
-    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
-)]
-pub struct CompilationDirectives {
-    /// Defines how the revert strings should be handled.
-    pub revert_string_handling: Option<RevertString>,
-}
-
-/// Defines how the compiler should handle revert strings.
-#[derive(
-    Clone, Debug, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Serialize, Deserialize,
-)]
-#[serde(rename_all = "camelCase")]
-pub enum RevertString {
-    #[default]
-    Default,
-    Debug,
-    Strip,
-    VerboseDebug,
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

crates/format/src/mode.rs

@@ -1,393 +1,123 @@
-use std::{fmt::Display, str::FromStr};
-
 use revive_dt_common::types::VersionOrRequirement;
 use semver::Version;
-use serde::Serialize;
+use serde::de::Deserializer;
+use serde::{Deserialize, Serialize};
 
-/// Specifies a compilation mode for the test artifact that it requires. This is used as a filter
+/// Specifies the compilation mode of the test artifact.
-/// when used in the [`Metadata`] and is used as a directive when used in the core crate.
+#[derive(Hash, Debug, Clone, Eq, PartialEq)]
-///
-/// [`Metadata`]: crate::metadata::Metadata
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Mode {
-    /// A compilation mode that's been parsed from a String and into its contents.
     Solidity(SolcMode),
-    /// An unknown compilation mode.
     Unknown(String),
 }
 
-impl From<Mode> for String {
+/// Specify Solidity specific compiler options.
-    fn from(value: Mode) -> Self {
+#[derive(Hash, Debug, Default, Clone, Eq, PartialEq, Serialize, Deserialize)]
-        value.to_string()
-    }
-}
-
-impl Display for Mode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Mode::Solidity(mode) => mode.fmt(f),
-            Mode::Unknown(string) => string.fmt(f),
-        }
-    }
-}
-
-impl Mode {
-    pub fn parse_from_string(str: impl AsRef<str>) -> Vec<Self> {
-        let mut chars = str.as_ref().chars().peekable();
-
-        let compile_via_ir = match chars.next() {
-            Some('Y') => true,
-            Some('E') => false,
-            _ => {
-                tracing::warn!("Encountered an unknown mode {}", str.as_ref());
-                return vec![Self::Unknown(str.as_ref().to_string())];
-            }
-        };
-
-        let optimize_flag = match chars.peek() {
-            Some('+') => {
-                let _ = chars.next();
-                Some(true)
-            }
-            Some('-') => {
-                let _ = chars.next();
-                Some(false)
-            }
-            _ => None,
-        };
-
-        let mut chars = chars.skip_while(|char| *char == ' ').peekable();
-
-        let version_requirement = match chars.peek() {
-            Some('=' | '>' | '<' | '~' | '^' | '*' | '0'..='9') => {
-                let version_requirement = chars.take_while(|char| *char != ' ').collect::<String>();
-                let Ok(version_requirement) = VersionOrRequirement::from_str(&version_requirement)
-                else {
-                    return vec![Self::Unknown(str.as_ref().to_string())];
-                };
-                Some(version_requirement)
-            }
-            _ => None,
-        };
-
-        match optimize_flag {
-            Some(flag) => {
-                vec![Self::Solidity(SolcMode {
-                    via_ir: compile_via_ir,
-                    optimize: flag,
-                    compiler_version_requirement: version_requirement,
-                })]
-            }
-            None => {
-                vec![
-                    Self::Solidity(SolcMode {
-                        via_ir: compile_via_ir,
-                        optimize: true,
-                        compiler_version_requirement: version_requirement.clone(),
-                    }),
-                    Self::Solidity(SolcMode {
-                        via_ir: compile_via_ir,
-                        optimize: false,
-                        compiler_version_requirement: version_requirement,
-                    }),
-                ]
-            }
-        }
-    }
-
-    pub fn matches(&self, other: &Self) -> bool {
-        match (self, other) {
-            (
-                Mode::Solidity(SolcMode {
-                    via_ir: self_via_ir,
-                    optimize: self_optimize,
-                    compiler_version_requirement: self_compiler_version_requirement,
-                }),
-                Mode::Solidity(SolcMode {
-                    via_ir: other_via_ir,
-                    optimize: other_optimize,
-                    compiler_version_requirement: other_compiler_version_requirement,
-                }),
-            ) => {
-                let mut matches = true;
-                matches &= self_via_ir == other_via_ir;
-                matches &= self_optimize == other_optimize;
-                match (
-                    self_compiler_version_requirement,
-                    other_compiler_version_requirement,
-                ) {
-                    (
-                        Some(VersionOrRequirement::Version(self_version)),
-                        Some(VersionOrRequirement::Version(other_version)),
-                    ) => {
-                        matches &= self_version == other_version;
-                    }
-                    (
-                        Some(VersionOrRequirement::Version(version)),
-                        Some(VersionOrRequirement::Requirement(requirement)),
-                    )
-                    | (
-                        Some(VersionOrRequirement::Requirement(requirement)),
-                        Some(VersionOrRequirement::Version(version)),
-                    ) => matches &= requirement.matches(version),
-                    (
-                        Some(VersionOrRequirement::Requirement(..)),
-                        Some(VersionOrRequirement::Requirement(..)),
-                    ) => matches = false,
-                    (Some(_), None) | (None, Some(_)) | (None, None) => {}
-                }
-                matches
-            }
-            (Mode::Solidity { .. }, Mode::Unknown(_))
-            | (Mode::Unknown(_), Mode::Solidity { .. })
-            | (Mode::Unknown(_), Mode::Unknown(_)) => false,
-        }
-    }
-
-    pub fn as_solc_mode(&self) -> Option<&SolcMode> {
-        if let Self::Solidity(mode) = self {
-            Some(mode)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-#[serde(into = "String")]
 pub struct SolcMode {
-    pub via_ir: bool,
+    pub solc_version: Option<semver::VersionReq>,
-    pub optimize: bool,
+    solc_optimize: Option<bool>,
-    pub compiler_version_requirement: Option<VersionOrRequirement>,
+    pub llvm_optimizer_settings: Vec<String>,
+    mode_string: String,
 }
 
 impl SolcMode {
-    pub const ALL: [Self; 4] = [
+    /// Try to parse a mode string into a solc mode.
-        SolcMode {
+    /// Returns `None` if the string wasn't a solc YUL mode string.
-            via_ir: false,
+    ///
-            optimize: false,
+    /// The mode string is expected to start with the `Y` ID (YUL ID),
-            compiler_version_requirement: None,
+    /// optionally followed by `+` or `-` for the solc optimizer settings.
-        },
+    ///
-        SolcMode {
+    /// Options can be separated by a whitespace contain the following
-            via_ir: false,
+    /// - A solc `SemVer version requirement` string
-            optimize: true,
+    /// - One or more `-OX` where X is a supposed to be an LLVM opt mode
-            compiler_version_requirement: None,
+    pub fn parse_from_mode_string(mode_string: &str) -> Option<Self> {
-        },
+        let mut result = Self {
-        SolcMode {
+            mode_string: mode_string.to_string(),
-            via_ir: true,
+            ..Default::default()
-            optimize: false,
+        };
-            compiler_version_requirement: None,
-        },
-        SolcMode {
-            via_ir: true,
-            optimize: true,
-            compiler_version_requirement: None,
-        },
-    ];
 
-    pub fn matches(&self, other: &Self) -> bool {
+        let mut parts = mode_string.trim().split(" ");
-        Mode::Solidity(self.clone()).matches(&Mode::Solidity(other.clone()))
+
+        match parts.next()? {
+            "Y" => {}
+            "Y+" => result.solc_optimize = Some(true),
+            "Y-" => result.solc_optimize = Some(false),
+            _ => return None,
+        }
+
+        for part in parts {
+            if let Ok(solc_version) = semver::VersionReq::parse(part) {
+                result.solc_version = Some(solc_version);
+                continue;
+            }
+            if let Some(level) = part.strip_prefix("-O") {
+                result.llvm_optimizer_settings.push(level.to_string());
+                continue;
+            }
+            panic!("the YUL mode string {mode_string} failed to parse, invalid part: {part}")
+        }
+
+        Some(result)
+    }
+
+    /// Returns whether to enable the solc optimizer.
+    pub fn solc_optimize(&self) -> bool {
+        self.solc_optimize.unwrap_or(true)
+    }
+
+    /// Calculate the latest matching solc patch version. Returns:
+    /// - `latest_supported` if no version request was specified.
+    /// - A matching version with the same minor version as `latest_supported`, if any.
+    /// - `None` if no minor version of the `latest_supported` version matches.
+    pub fn last_patch_version(&self, latest_supported: &Version) -> Option<Version> {
+        let Some(version_req) = self.solc_version.as_ref() else {
+            return Some(latest_supported.to_owned());
+        };
+
+        // lgtm
+        for patch in (0..latest_supported.patch + 1).rev() {
+            let version = Version::new(0, latest_supported.minor, patch);
+            if version_req.matches(&version) {
+                return Some(version);
+            }
+        }
+
+        None
     }
 
     /// Resolves the [`SolcMode`]'s solidity version requirement into a [`VersionOrRequirement`] if
     /// the requirement is present on the object. Otherwise, the passed default version is used.
     pub fn compiler_version_to_use(&self, default: Version) -> VersionOrRequirement {
-        match self.compiler_version_requirement {
+        match self.solc_version {
-            Some(ref requirement) => requirement.clone(),
+            Some(ref requirement) => requirement.clone().into(),
             None => default.into(),
         }
     }
 }
 
-impl Display for SolcMode {
+impl<'de> Deserialize<'de> for Mode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        let Self {
+    where
-            via_ir,
+        D: Deserializer<'de>,
-            optimize,
+    {
-            compiler_version_requirement,
+        let mode_string = String::deserialize(deserializer)?;
-        } = self;
 
-        if *via_ir {
+        if let Some(solc_mode) = SolcMode::parse_from_mode_string(&mode_string) {
-            write!(f, "Y")?;
+            return Ok(Self::Solidity(solc_mode));
-        } else {
-            write!(f, "E")?;
         }
 
-        if *optimize {
+        Ok(Self::Unknown(mode_string))
-            write!(f, "+")?;
-        } else {
-            write!(f, "-")?;
-        }
-
-        if let Some(req) = compiler_version_requirement {
-            write!(f, " {req}")?;
-        }
-
-        Ok(())
     }
 }
 
-impl From<SolcMode> for String {
+impl Serialize for Mode {
-    fn from(value: SolcMode) -> Self {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        value.to_string()
+    where
-    }
+        S: serde::Serializer,
-}
+    {
-
+        let string = match self {
-#[cfg(test)]
+            Mode::Solidity(solc_mode) => &solc_mode.mode_string,
-mod test {
+            Mode::Unknown(string) => string,
-    use semver::Version;
+        };
-
+        string.serialize(serializer)
-    use super::*;
-
-    #[test]
-    fn mode_can_be_parsed_as_expected() {
-        // Arrange
-        let fixtures = [
-            (
-                "Y",
-                vec![
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: true,
-                        compiler_version_requirement: None,
-                    }),
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: false,
-                        compiler_version_requirement: None,
-                    }),
-                ],
-            ),
-            (
-                "Y+",
-                vec![Mode::Solidity(SolcMode {
-                    via_ir: true,
-                    optimize: true,
-                    compiler_version_requirement: None,
-                })],
-            ),
-            (
-                "Y-",
-                vec![Mode::Solidity(SolcMode {
-                    via_ir: true,
-                    optimize: false,
-                    compiler_version_requirement: None,
-                })],
-            ),
-            (
-                "E",
-                vec![
-                    Mode::Solidity(SolcMode {
-                        via_ir: false,
-                        optimize: true,
-                        compiler_version_requirement: None,
-                    }),
-                    Mode::Solidity(SolcMode {
-                        via_ir: false,
-                        optimize: false,
-                        compiler_version_requirement: None,
-                    }),
-                ],
-            ),
-            (
-                "E+",
-                vec![Mode::Solidity(SolcMode {
-                    via_ir: false,
-                    optimize: true,
-                    compiler_version_requirement: None,
-                })],
-            ),
-            (
-                "E-",
-                vec![Mode::Solidity(SolcMode {
-                    via_ir: false,
-                    optimize: false,
-                    compiler_version_requirement: None,
-                })],
-            ),
-            (
-                "Y >=0.8.3",
-                vec![
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: true,
-                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
-                            ">=0.8.3".parse().unwrap(),
-                        )),
-                    }),
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: false,
-                        compiler_version_requirement: Some(VersionOrRequirement::Requirement(
-                            ">=0.8.3".parse().unwrap(),
-                        )),
-                    }),
-                ],
-            ),
-            (
-                "Y 0.8.3",
-                vec![
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: true,
-                        compiler_version_requirement: Some(VersionOrRequirement::Version(
-                            Version {
-                                major: 0,
-                                minor: 8,
-                                patch: 3,
-                                pre: Default::default(),
-                                build: Default::default(),
-                            },
-                        )),
-                    }),
-                    Mode::Solidity(SolcMode {
-                        via_ir: true,
-                        optimize: false,
-                        compiler_version_requirement: Some(VersionOrRequirement::Version(
-                            Version {
-                                major: 0,
-                                minor: 8,
-                                patch: 3,
-                                pre: Default::default(),
-                                build: Default::default(),
-                            },
-                        )),
-                    }),
-                ],
-            ),
-        ];
-
-        for (string, expectation) in fixtures {
-            // Act
-            let actual = Mode::parse_from_string(string);
-
-            // Assert
-            assert_eq!(
-                actual, expectation,
-                "Parsed {string} into {actual:?} but expected {expectation:?}"
-            )
-        }
-    }
-
-    #[test]
-    #[allow(clippy::uninlined_format_args)]
-    fn mode_matches_as_expected() {
-        // Arrange
-        let fixtures = [("Y+", "Y+", true), ("Y+ >=0.8.3", "Y+", true)];
-
-        for (self_mode, other_mode, expected_result) in fixtures {
-            let self_mode = Mode::parse_from_string(self_mode).pop().unwrap();
-            let other_mode = Mode::parse_from_string(other_mode).pop().unwrap();
-
-            // Act
-            let actual = self_mode.matches(&other_mode);
-
-            // Assert
-            assert_eq!(
-                actual, expected_result,
-                "Match of {} and {} failed. Expected {} but got {}",
-                self_mode, other_mode, expected_result, actual
-            );
-        }
     }
 }

crates/node/src/geth.rs

@@ -33,7 +33,7 @@ use alloy::{
 };
 use anyhow::Context;
 use revive_common::EVMVersion;
-use tracing::Instrument;
+use tracing::{Instrument, Level};
 
 use revive_dt_common::{fs::clear_directory, futures::poll};
 use revive_dt_config::Arguments;
@@ -48,7 +48,7 @@ static NODE_COUNT: AtomicU32 = AtomicU32::new(0);
 ///
 /// Implements helpers to initialize, spawn and wait the node.
 ///
-/// Assumes dev mode and IPC only (`P2P`, `http` etc. are kept disabled).
+/// Assumes dev mode and IPC only (`P2P`, `http`` etc. are kept disabled).
 ///
 /// Prunes the child process and the base directory on drop.
 #[derive(Debug)]
@@ -228,12 +228,12 @@ impl GethNode {
         }
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
     fn geth_stdout_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDOUT_LOG_FILE_NAME)
     }
 
-    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = "trace")]
+    #[tracing::instrument(skip_all, fields(geth_node_id = self.id), level = Level::TRACE)]
     fn geth_stderr_log_file_path(&self) -> PathBuf {
         self.logs_directory.join(Self::GETH_STDERR_LOG_FILE_NAME)
     }
@@ -257,18 +257,13 @@ impl GethNode {
         Box::pin(async move {
             ProviderBuilder::new()
                 .disable_recommended_fillers()
-                .filler(FallbackGasFiller::new(
+                .filler(FallbackGasFiller::new(500_000_000, 500_000_000, 1))
-                    25_000_000,
-                    100_000_000_000,
-                    1_000_000_000,
-                ))
                 .filler(ChainIdFiller::default())
                 .filler(NonceFiller::new(nonce_manager))
                 .wallet(wallet)
                 .connect(&connection_string)
                 .await
                 .map_err(Into::into)
-                .inspect_err(|err| tracing::error!(%err, "Failed to create the alloy provider"))
         })
     }
 }
@@ -282,26 +277,27 @@ impl EthereumNode for GethNode {
         let span = tracing::debug_span!("Submitting transaction", ?transaction);
         let _guard = span.enter();
 
-        let provider = self.provider().await.map(Arc::new)?;
+        let provider = Arc::new(self.provider().await?);
         let transaction_hash = *provider.send_transaction(transaction).await?.tx_hash();
 
-        // The following is a fix for the "transaction indexing is in progress" error that we used
+        // The following is a fix for the "transaction indexing is in progress" error that we
-        // to get. You can find more information on this in the following GH issue in geth
+        // used to get. You can find more information on this in the following GH issue in geth
         // https://github.com/ethereum/go-ethereum/issues/28877. To summarize what's going on,
         // before we can get the receipt of the transaction it needs to have been indexed by the
-        // node's indexer. Just because the transaction has been confirmed it doesn't mean that it
+        // node's indexer. Just because the transaction has been confirmed it doesn't mean that
-        // has been indexed. When we call alloy's `get_receipt` it checks if the transaction was
+        // it has been indexed. When we call alloy's `get_receipt` it checks if the transaction
-        // confirmed. If it has been, then it will call `eth_getTransactionReceipt` method which
+        // was confirmed. If it has been, then it will call `eth_getTransactionReceipt` method
-        // _might_ return the above error if the tx has not yet been indexed yet. So, we need to
+        // which _might_ return the above error if the tx has not yet been indexed yet. So, we
-        // implement a retry mechanism for the receipt to keep retrying to get it until it
+        // need to implement a retry mechanism for the receipt to keep retrying to get it until
-        // eventually works, but we only do that if the error we get back is the "transaction
+        // it eventually works, but we only do that if the error we get back is the "transaction
         // indexing is in progress" error or if the receipt is None.
         //
         // Getting the transaction indexed and taking a receipt can take a long time especially
-        // when a lot of transactions are being submitted to the node. Thus, while initially we only
+        // when a lot of transactions are being submitted to the node. Thus, while initially we
-        // allowed for 60 seconds of waiting with a 1 second delay in polling, we need to allow for
+        // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
-        // a larger wait time. Therefore, in here we allow for 5 minutes of waiting with exponential
+        // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
-        // backoff each time we attempt to get the receipt and find that it's not available.
+        // with exponential backoff each time we attempt to get the receipt and find that it's
+        // not available.
         poll(
             Self::RECEIPT_POLLING_DURATION,
             Default::default(),
@@ -327,7 +323,6 @@ impl EthereumNode for GethNode {
             ?transaction_hash
         ))
         .await
-        .inspect(|receipt| tracing::info!(gas_used = receipt.gas_used, "Gas used on transaction"))
     }
 
     #[tracing::instrument(level = "info", skip_all, fields(geth_node_id = self.id), err)]

crates/node/src/pool.rs

@@ -1,12 +1,11 @@
 //! This crate implements concurrent handling of testing node.
 
 use std::{
+    fs::read_to_string,
     sync::atomic::{AtomicUsize, Ordering},
     thread,
 };
 
-use revive_dt_common::cached_fs::read_to_string;
-
 use anyhow::Context;
 use revive_dt_config::Arguments;
 

crates/report/src/reporter.rs

@@ -13,7 +13,7 @@ use std::{
 
 use anyhow::Context;
 use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use revive_dt_config::{Arguments, TestingPlatform};
 use revive_dt_format::{corpus::Corpus, mode::SolcMode};
@@ -23,7 +23,7 @@ use crate::analyzer::CompilerStatistics;
 pub(crate) static REPORTER: OnceLock<Mutex<Report>> = OnceLock::new();
 
 /// The `Report` datastructure stores all relevant inforamtion required for generating reports.
-#[derive(Clone, Debug, Default, Serialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct Report {
     /// The configuration used during the test.
     pub config: Arguments,
@@ -41,7 +41,7 @@ pub struct Report {
 }
 
 /// Contains a compiled contract.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompilationTask {
     /// The observed compiler input.
     pub json_input: CompilerInput,
@@ -56,7 +56,7 @@ pub struct CompilationTask {
 }
 
 /// Represents a report about a compilation task.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompilationResult {
     /// The observed compilation task.
     pub compilation_task: CompilationTask,
@@ -65,7 +65,7 @@ pub struct CompilationResult {
 }
 
 /// The [Span] struct indicates the context of what is being reported.
-#[derive(Clone, Copy, Debug, Serialize)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
 pub struct Span {
     /// The corpus index this belongs to.
     corpus: usize,