Support multiple compiler versions (#92)

* Allow for downloader to use version requirements.

We will soon add support for the compiler version requirement from the
metadata files to be honored. The compiler version is specified in the
solc modes section of the file and its specified as a `VersionReq` and
not as a version.

Therefore, we need to have the ability to honor this version requirement
and find the best version that satisfies the requirement.

* Request `VersionOrRequirement` in compiler interface

* Honor the compiler version requirement in metadata

This commit honors the compiler version requirement listed in the solc
modes of the metadata file. If this version requirement is provided then
it overrides what was passed in the CLI. Otherwise, the CLI version will
be used.

* Make compiler IO completely generic.

Before this commit, the types that were used for the compiler input and
output were the resolc compiler types which was a leaky abstraction as
we have traits to abstract the compilers away but we expose their
internal types out to other crates.

This commit did the following:
1. Made the compiler IO types fully generic so that all of the logic for
   constructing the map of compiled contracts is all done by the
   compiler implementation and not by the consuming code.
2. Changed the input types used for Solc to be the forge standard JSON
   types for Solc instead of resolc.

* Fix machete

* Add resolc to CI

* Add resolc to CI

* Add resolc to CI

* Add resolc to CI

crates/format/src/metadata.rs

@@ -9,7 +9,7 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
-use revive_dt_common::macros::define_wrapper_type;
+use revive_dt_common::{iterators::FilesWithExtensionIterator, macros::define_wrapper_type};
 
 use crate::{
     case::Case,
@@ -212,6 +212,29 @@ impl Metadata {
             }
         }
     }
+
+    /// Returns an iterator over all of the solidity files that needs to be compiled for this
+    /// [`Metadata`] object
+    ///
+    /// Note: if the metadata is contained within a solidity file then this is the only file that
+    /// we wish to compile since this is a self-contained test. Otherwise, if it's a JSON file
+    /// then we need to compile all of the contracts that are in the directory since imports are
+    /// allowed in there.
+    pub fn files_to_compile(&self) -> anyhow::Result<Box<dyn Iterator<Item = PathBuf>>> {
+        let Some(ref metadata_file_path) = self.file_path else {
+            anyhow::bail!("The metadata file path is not defined");
+        };
+        if metadata_file_path
+            .extension()
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("sol"))
+        {
+            Ok(Box::new(std::iter::once(metadata_file_path.clone())))
+        } else {
+            Ok(Box::new(
+                FilesWithExtensionIterator::new(self.directory()?).with_allowed_extension("sol"),
+            ))
+        }
+    }
 }
 
 define_wrapper_type!(

crates/format/src/mode.rs

@@ -1,3 +1,4 @@
+use revive_dt_common::types::VersionOrRequirement;
 use semver::Version;
 use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
@@ -78,6 +79,15 @@ impl SolcMode {
 
         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.solc_version {
+            Some(ref requirement) => requirement.clone().into(),
+            None => default.into(),
+        }
+    }
 }
 
 impl<'de> Deserialize<'de> for Mode {