Allow for compilers to be created in the dyn trait

crates/compiler/src/lib.rs

@@ -7,6 +7,7 @@ use std::{
     collections::HashMap,
     hash::Hash,
     path::{Path, PathBuf},
+    pin::Pin,
 };
 
 use alloy::json_abi::JsonAbi;
@@ -27,13 +28,33 @@ pub mod revive_js;
 pub mod revive_resolc;
 pub mod solc;
 
+/// A common interface for all supported Solidity compilers.
+pub trait DynSolidityCompiler {
+    /// Returns the version of the compiler.
+    fn version(&self) -> &Version;
+
+    /// Returns the path of the compiler executable.
+    fn path(&self) -> &Path;
+
+    /// The low-level compiler interface.
+    fn build(&self, input: CompilerInput) -> Pin<Box<dyn Future<Output = Result<CompilerOutput>>>>;
+
+    /// Does the compiler support the provided mode and version settings.
+    fn supports_mode(
+        &self,
+        optimizer_setting: ModeOptimizerSetting,
+        pipeline: ModePipeline,
+    ) -> bool;
+}
+
+// TODO: Remove
 /// A common interface for all supported Solidity compilers.
 pub trait SolidityCompiler: Sized {
     /// Instantiates a new compiler object.
     ///
-    /// Based on the given [`Context`] and [`VersionOrRequirement`] this function instantiates a
+    /// Based on the given context and [`VersionOrRequirement`] this function instantiates a
-    /// new compiler object. Certain implementations of this trait might choose to cache cache the
+    /// new compiler object. Certain implementations of this trait might choose to cache the
-    /// compiler objects and return the same ones over and over again.
+    /// compiler objects and return the same compiler objects if given the same set of arguments.
     fn new(
         context: impl AsRef<SolcConfiguration>
         + AsRef<ResolcConfiguration>
@@ -74,7 +95,7 @@ pub struct CompilerInput {
 /// The generic compilation output configuration.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct CompilerOutput {
-    /// The compiled contracts. The bytecode of the contract is kept as a string incase linking is
+    /// The compiled contracts. The bytecode of the contract is kept as a string in case linking is
     /// required and the compiled source has placeholders.
     pub contracts: HashMap<PathBuf, HashMap<String, (String, JsonAbi)>>,
 }

crates/core/src/lib.rs

@@ -3,8 +3,9 @@
 //! This crate defines the testing configuration and
 //! provides a helper utility to execute tests.
 
-use revive_dt_compiler::{SolidityCompiler, revive_resolc, solc};
+use revive_dt_common::types::VersionOrRequirement;
-use revive_dt_config::{PlatformIdentifier, TestingPlatform};
+use revive_dt_compiler::{DynSolidityCompiler, SolidityCompiler, revive_resolc, solc};
+use revive_dt_config::*;
 use revive_dt_format::traits::ResolverApi;
 use revive_dt_node::{Node, geth, kitchensink::KitchensinkNode};
 use revive_dt_node_interaction::EthereumNode;
@@ -53,5 +54,28 @@ pub trait DynPlatform {
 
     /// Creates a new node for the platform by spawning a new thread, creating the node object,
     /// initializing it, spawning it, and waiting for it to start up.
-    fn new_node(&self) -> Box<dyn EthereumNode>;
+    fn new_node(
+        &self,
+        context: impl AsRef<WorkingDirectoryConfiguration>
+        + AsRef<ConcurrencyConfiguration>
+        + AsRef<GenesisConfiguration>
+        + AsRef<WalletConfiguration>
+        + AsRef<GethConfiguration>
+        + AsRef<KitchensinkConfiguration>
+        + AsRef<ReviveDevNodeConfiguration>
+        + AsRef<EthRpcConfiguration>
+        + Send
+        + Sync
+        + Clone
+        + 'static,
+    ) -> Box<dyn EthereumNode>;
+
+    /// Creates a new compiler for the provided platform
+    fn new_compiler(
+        &self,
+        context: impl AsRef<SolcConfiguration>
+        + AsRef<ResolcConfiguration>
+        + AsRef<WorkingDirectoryConfiguration>,
+        version: impl Into<Option<VersionOrRequirement>>,
+    ) -> Box<dyn DynSolidityCompiler>;
 }

crates/node/src/pool.rs

@@ -17,7 +17,7 @@ use tracing::info;
 use crate::Node;
 
 /// The node pool starts one or more [Node] which then can be accessed
-/// in a round robbin fasion.
+/// in a round robbin fashion.
 pub struct NodePool<T> {
     next: AtomicUsize,
     nodes: Vec<T>,