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.

crates/solc-binaries/src/download.rs

@@ -5,7 +5,7 @@ use std::{
     sync::{LazyLock, Mutex},
 };
 
-use semver::Version;
+use semver::{Version, VersionReq};
 use sha2::{Digest, Sha256};
 
 use crate::list::List;
@@ -52,27 +52,50 @@ impl GHDownloader {
     pub const WINDOWS_NAME: &str = "solc-windows.exe";
     pub const WASM_NAME: &str = "soljson.js";
 
-    fn new(version: Version, target: &'static str, list: &'static str) -> Self {
-        Self {
-            version,
-            target,
-            list,
+    fn new(
+        version: impl Into<VersionOrRequirement>,
+        target: &'static str,
+        list: &'static str,
+    ) -> anyhow::Result<Self> {
+        let version_or_requirement = version.into();
+        match version_or_requirement {
+            VersionOrRequirement::Version(version) => Ok(Self {
+                version,
+                target,
+                list,
+            }),
+            VersionOrRequirement::Requirement(requirement) => {
+                let Some(version) = List::download(list)?
+                    .builds
+                    .into_iter()
+                    .map(|build| build.version)
+                    .filter(|version| requirement.matches(version))
+                    .max()
+                else {
+                    anyhow::bail!("Failed to find a version that satisfies {requirement:?}");
+                };
+                Ok(Self {
+                    version,
+                    target,
+                    list,
+                })
+            }
         }
     }
 
-    pub fn linux(version: Version) -> Self {
+    pub fn linux(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
         Self::new(version, Self::LINUX_NAME, List::LINUX_URL)
     }
 
-    pub fn macosx(version: Version) -> Self {
+    pub fn macosx(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
         Self::new(version, Self::MACOSX_NAME, List::MACOSX_URL)
     }
 
-    pub fn windows(version: Version) -> Self {
+    pub fn windows(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
         Self::new(version, Self::WINDOWS_NAME, List::WINDOWS_URL)
     }
 
-    pub fn wasm(version: Version) -> Self {
+    pub fn wasm(version: impl Into<VersionOrRequirement>) -> anyhow::Result<Self> {
         Self::new(version, Self::WASM_NAME, List::WASM_URL)
     }
 
@@ -104,6 +127,24 @@ impl GHDownloader {
     }
 }
 
+#[derive(Clone, Debug)]
+pub enum VersionOrRequirement {
+    Version(Version),
+    Requirement(VersionReq),
+}
+
+impl From<Version> for VersionOrRequirement {
+    fn from(value: Version) -> Self {
+        Self::Version(value)
+    }
+}
+
+impl From<VersionReq> for VersionOrRequirement {
+    fn from(value: VersionReq) -> Self {
+        Self::Requirement(value)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{download::GHDownloader, list::List};
@@ -111,24 +152,24 @@ mod tests {
     #[test]
     fn try_get_windows() {
         let version = List::download(List::WINDOWS_URL).unwrap().latest_release;
-        GHDownloader::windows(version).download().unwrap();
+        GHDownloader::windows(version).unwrap().download().unwrap();
     }
 
     #[test]
     fn try_get_macosx() {
         let version = List::download(List::MACOSX_URL).unwrap().latest_release;
-        GHDownloader::macosx(version).download().unwrap();
+        GHDownloader::macosx(version).unwrap().download().unwrap();
     }
 
     #[test]
     fn try_get_linux() {
         let version = List::download(List::LINUX_URL).unwrap().latest_release;
-        GHDownloader::linux(version).download().unwrap();
+        GHDownloader::linux(version).unwrap().download().unwrap();
     }
 
     #[test]
     fn try_get_wasm() {
         let version = List::download(List::WASM_URL).unwrap().latest_release;
-        GHDownloader::wasm(version).download().unwrap();
+        GHDownloader::wasm(version).unwrap().download().unwrap();
     }
 }

crates/solc-binaries/src/lib.rs

@@ -7,7 +7,8 @@ use std::path::{Path, PathBuf};
 
 use cache::get_or_download;
 use download::GHDownloader;
-use semver::Version;
+
+use crate::download::VersionOrRequirement;
 
 pub mod cache;
 pub mod download;
@@ -20,7 +21,7 @@ pub mod list;
 /// and not download it again.
 pub fn download_solc(
     cache_directory: &Path,
-    version: Version,
+    version: impl Into<VersionOrRequirement>,
     wasm: bool,
 ) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
@@ -33,7 +34,7 @@ pub fn download_solc(
         GHDownloader::windows(version)
     } else {
         unimplemented!()
-    };
+    }?;
 
     get_or_download(cache_directory, &downloader)
 }