chore: support for Windows ARM64 (#174)

This PR add support for Windows ARM64. Since there is no dedicated
Solidity version for Windows ARM64 it use the x86 version. Which seems
to work fine using x86 emulation. I was undecided about removing the
`target_arch` for Windows altogether, but I kept it to mark it as a
tested variant.

**Before this PR:**
During the build it was trying to fetch
"https://binaries.soliditylang.org/Unsupported-platform/list.json"
(there is no further error handling if the request fails):
```
PS C:\Users\cakevm\Documents\projects\rust\svm-rs> cargo build
   Compiling svm-rs-builds v0.5.19 (C:\Users\cakevm\Documents\projects\rust\svm-rs\crates\svm-builds)
error: failed to run custom build command for `svm-rs-builds v0.5.19 (C:\Users\cakevm\Documents\projects\rust\svm-rs\crates\svm-builds)`                                

Caused by:
  process didn't exit successfully: `C:\Users\cakevm\Documents\projects\rust\svm-rs\target\debug\build\svm-rs-builds-34686cb3a1738671\build-script-build` (exit code: 101)
  --- stderr

  thread 'main' (5676) panicked at crates\svm-builds\build.rs:150:46:
  Failed to fetch releases: ReqwestError(reqwest::Error { kind: Decode, source: Error("expected value", line: 1, column: 1) })
  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
  ```

Author: cakevm

crates/svm-rs/Cargo.toml

@@ -57,7 +57,7 @@ tokio = { version = "1", features = [
     "macros",
 ], optional = true }
 
-[target.'cfg(all(target_os = "windows", target_arch = "x86_64"))'.dependencies]
+[target.'cfg(target_os = "windows")'.dependencies]
 zip = { version = "4", default-features = false, features = ["deflate"] }
 
 [dev-dependencies]

crates/svm-rs/src/bin/solc/main.rs

@@ -6,7 +6,7 @@
 )]
 #![warn(rustdoc::all)]
 #![deny(unused_must_use, rust_2018_idioms)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use anyhow::Context;
 use std::io;

crates/svm-rs/src/bin/svm-bin/main.rs

@@ -6,7 +6,7 @@
 )]
 #![warn(rustdoc::all)]
 #![deny(unused_must_use, rust_2018_idioms)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use clap::Parser;
 

crates/svm-rs/src/error.rs

@@ -36,7 +36,7 @@ pub enum SvmError {
     UrlError(#[from] url::ParseError),
     #[error("Received unsuccessful response with code {1} for {0}")]
     UnsuccessfulResponse(Url, StatusCode),
-    #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
+    #[cfg(target_os = "windows")]
     #[error(transparent)]
     ZipError(#[from] zip::result::ZipError),
 }

crates/svm-rs/src/install.rs

@@ -161,7 +161,7 @@ fn do_install(version: &Version, binbytes: &[u8], _artifact: &str) -> Result<Pat
     let installer = Installer { version, binbytes };
 
     // Solc versions <= 0.7.1 are .zip files for Windows only
-    #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
+    #[cfg(target_os = "windows")]
     if _artifact.ends_with(".zip") {
         return installer.install_zip();
     }
@@ -243,7 +243,7 @@ impl Installer<'_> {
 
     /// Extracts the solc archive at the version specified destination and returns the path to the
     /// installed solc binary.
-    #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
+    #[cfg(target_os = "windows")]
     fn install_zip(self) -> Result<PathBuf, SvmError> {
         let solc_path = version_binary(&self.version.to_string());
         let version_path = solc_path.parent().unwrap();
@@ -328,17 +328,33 @@ mod tests {
         } else {
             "which"
         };
+        // Long-running command: `sleep infinity` on Unix, `timeout /t 3600` on Windows
+        const CMD: &str = if cfg!(target_os = "windows") {
+            "timeout"
+        } else {
+            "sleep"
+        };
 
         let version: Version = "0.8.10".parse().unwrap();
         let solc_path = version_binary(version.to_string().as_str());
 
         fs::create_dir_all(solc_path.parent().unwrap()).unwrap();
 
-        // Overwrite solc with `sleep` and call it with `infinity`.
-        let stdout = Command::new(WHICH).arg("sleep").output().unwrap().stdout;
-        let sleep_path = String::from_utf8(stdout).unwrap();
-        fs::copy(sleep_path.trim_end(), &solc_path).unwrap();
-        let mut child = Command::new(solc_path).arg("infinity").spawn().unwrap();
+        // Overwrite solc with a long-running command.
+        let stdout = Command::new(WHICH).arg(CMD).output().unwrap().stdout;
+        let cmd_path = String::from_utf8(stdout).unwrap();
+        // On Windows, `where` can return multiple paths - take the first one
+        let cmd_path = cmd_path.lines().next().unwrap_or(&cmd_path);
+        fs::copy(cmd_path.trim_end(), &solc_path).unwrap();
+
+        let mut child = if cfg!(target_os = "windows") {
+            Command::new(&solc_path)
+                .args(["/t", "3600"])
+                .spawn()
+                .unwrap()
+        } else {
+            Command::new(&solc_path).arg("infinity").spawn().unwrap()
+        };
 
         // Install should not fail with "text file busy".
         install(&version).await.unwrap();
@@ -458,7 +474,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[cfg(all(target_os = "windows", target_arch = "x86_64"))]
+    #[cfg(target_os = "windows")]
     async fn can_install_windows_zip_release() {
         let version = "0.7.1".parse().unwrap();
         install(&version).await.unwrap();

crates/svm-rs/src/lib.rs

@@ -9,7 +9,7 @@
     warn(unused_crate_dependencies)
 )]
 #![deny(unused_must_use, rust_2018_idioms)]
-#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use semver::Version;
 use std::fs;

crates/svm-rs/src/platform.rs

@@ -11,6 +11,7 @@ pub enum Platform {
     MacOsAmd64,
     MacOsAarch64,
     WindowsAmd64,
+    WindowsAarch64,
     AndroidAarch64,
     Unsupported,
 }
@@ -23,6 +24,7 @@ impl fmt::Display for Platform {
             Self::MacOsAmd64 => "macosx-amd64",
             Self::MacOsAarch64 => "macosx-aarch64",
             Self::WindowsAmd64 => "windows-amd64",
+            Self::WindowsAarch64 => "windows-aarch64",
             Self::AndroidAarch64 => "android-aarch64",
             Self::Unsupported => "Unsupported-platform",
         };
@@ -40,6 +42,7 @@ impl FromStr for Platform {
             "macosx-amd64" => Ok(Self::MacOsAmd64),
             "macosx-aarch64" => Ok(Self::MacOsAarch64),
             "windows-amd64" => Ok(Self::WindowsAmd64),
+            "windows-aarch64" => Ok(Self::WindowsAarch64),
             "android-aarch64" => Ok(Self::AndroidAarch64),
             s => Err(format!("unsupported platform {s}")),
         }
@@ -61,6 +64,7 @@ pub fn platform() -> Platform {
         ("macos", "x86_64") => Platform::MacOsAmd64,
         ("macos", "aarch64") => Platform::MacOsAarch64,
         ("windows", "x86_64") => Platform::WindowsAmd64,
+        ("windows", "aarch64") => Platform::WindowsAarch64,
         ("android", "aarch64") => Platform::AndroidAarch64,
         _ => Platform::Unsupported,
     }
@@ -100,6 +104,12 @@ mod tests {
         assert_eq!(platform(), Platform::WindowsAmd64);
     }
 
+    #[test]
+    #[cfg(all(target_os = "windows", target_arch = "aarch64"))]
+    fn get_platform() {
+        assert_eq!(platform(), Platform::WindowsAarch64);
+    }
+
     #[test]
     #[cfg(all(target_os = "android", target_arch = "aarch64"))]
     fn get_platform() {

crates/svm-rs/src/releases.rs

@@ -166,6 +166,16 @@ pub fn blocking_all_releases(platform: Platform) -> Result<Releases, SvmError> {
         Platform::AndroidAarch64 => {
             Ok(reqwest::blocking::get(ANDROID_AARCH64_RELEASES_URL)?.json::<Releases>()?)
         }
+        Platform::WindowsAarch64 => {
+            // Windows ARM64 uses x64 binaries via emulation
+            // Solidity does not provide native ARM64 Windows binaries
+            let releases = reqwest::blocking::get(format!(
+                "{SOLC_RELEASES_URL}/{}/list.json",
+                Platform::WindowsAmd64
+            ))?
+            .json::<Releases>()?;
+            Ok(unified_releases(releases, platform))
+        }
         _ => {
             let releases =
                 reqwest::blocking::get(format!("{SOLC_RELEASES_URL}/{platform}/list.json"))?
@@ -217,6 +227,19 @@ pub async fn all_releases(platform: Platform) -> Result<Releases, SvmError> {
             .await?
             .json::<Releases>()
             .await?),
+        Platform::WindowsAarch64 => {
+            // Windows ARM64 uses x64 binaries via emulation
+            // Solidity does not provide native ARM64 Windows binaries
+            let releases = get(format!(
+                "{SOLC_RELEASES_URL}/{}/list.json",
+                Platform::WindowsAmd64
+            ))
+            .await?
+            .json::<Releases>()
+            .await?;
+
+            Ok(unified_releases(releases, platform))
+        }
         _ => {
             let releases = get(format!("{SOLC_RELEASES_URL}/{platform}/list.json"))
                 .await?
@@ -305,6 +328,15 @@ pub(crate) fn artifact_url(
         }
     }
 
+    if platform == Platform::WindowsAarch64 {
+        // Windows ARM64 uses x64 binaries via emulation
+        // Solidity does not provide native ARM64 Windows binaries
+        return Ok(Url::parse(&format!(
+            "{SOLC_RELEASES_URL}/{}/{artifact}",
+            Platform::WindowsAmd64,
+        ))?);
+    }
+
     Ok(Url::parse(&format!(
         "{SOLC_RELEASES_URL}/{platform}/{artifact}"
     ))?)
@@ -376,6 +408,18 @@ mod tests {
         assert!(all_releases(Platform::LinuxAarch64).await.is_ok());
     }
 
+    #[tokio::test]
+    async fn test_all_releases_windows_aarch64() {
+        let releases = all_releases(Platform::WindowsAarch64).await;
+        assert!(releases.is_ok());
+        // Check also that we got the windows-amd64 release
+        let releases = releases.unwrap();
+        let latest = releases.releases.keys().max().unwrap();
+        let artifact = releases.get_artifact(latest).unwrap();
+        let url = artifact_url(Platform::WindowsAarch64, latest, artifact).unwrap();
+        assert!(url.to_string().contains("windows-amd64"));
+    }
+
     #[tokio::test]
     async fn releases_roundtrip() {
         let releases = all_releases(Platform::LinuxAmd64).await.unwrap();