Refactor USC

Author: ksew1

Cargo.lock

@@ -143,7 +143,6 @@ mod tests {
         fixture::{FileWriteStr, PathChild},
     };
     use scarb_api::ScarbCommand;
-    use universal_sierra_compiler_api::UniversalSierraCompilerCommand;
 
     #[test]
     fn happy_case() {
@@ -178,7 +177,7 @@ mod tests {
         });
         requirements_checker.add_requirement(Requirement {
             name: "Universal Sierra Compiler".to_string(),
-            command: RefCell::new(UniversalSierraCompilerCommand::new().arg("--version").command()),
+            command: RefCell::new(universal_sierra_compiler_api::version_command().unwrap()),
             minimal_version: Version::new(2, 0, 0),
              minimal_recommended_version: None,
             helper_text: "Reinstall `snforge` using the same installation method or follow instructions from https://foundry-rs.github.io/starknet-foundry/getting-started/installation.html#universal-sierra-compiler-update".to_string(),
@@ -300,7 +299,7 @@ mod tests {
         });
         requirements_checker.add_requirement(Requirement {
             name: "Universal Sierra Compiler".to_string(),
-            command: RefCell::new(UniversalSierraCompilerCommand::new().arg("--version").command()),
+            command: RefCell::new(universal_sierra_compiler_api::version_command().unwrap()),
             minimal_version: Version::new(2, 4, 0),
             minimal_recommended_version: None,
             helper_text: "Reinstall `snforge` using the same installation method or follow instructions from https://foundry-rs.github.io/starknet-foundry/getting-started/installation.html#universal-sierra-compiler-update".to_string(),

crates/forge/src/compatibility_check.rs

@@ -18,7 +18,6 @@ use std::ffi::OsString;
 use std::sync::Arc;
 use std::{fs, num::NonZeroU32, thread::available_parallelism};
 use tokio::runtime::Builder;
-use universal_sierra_compiler_api::UniversalSierraCompilerCommand;
 
 pub mod block_number_map;
 mod clean;
@@ -362,7 +361,7 @@ fn check_requirements(output_on_success: bool, ui: &UI) -> Result<()> {
 
     requirements_checker.add_requirement(Requirement {
         name: "Universal Sierra Compiler".to_string(),
-        command: RefCell::new(UniversalSierraCompilerCommand::new().arg("--version").command()),
+        command: RefCell::new(universal_sierra_compiler_api::version_command()?),
         minimal_version: MINIMAL_USC_VERSION,
         minimal_recommended_version: None,
         helper_text: "Reinstall `snforge` using the same installation method or follow instructions from https://foundry-rs.github.io/starknet-foundry/getting-started/installation.html#universal-sierra-compiler-update".to_string(),

crates/forge/src/lib.rs

@@ -19,6 +19,7 @@ clap_complete.workspace = true
 cairo-vm.workspace = true
 num-traits.workspace = true
 foundry-ui ={ path = "../foundry-ui" }
+thiserror = "2.0.17"
 
 [features]
 testing = []

crates/shared/Cargo.toml

@@ -1,22 +1,42 @@
-use anyhow::{Context, Ok, Result, bail};
-use std::process::{Command, Output};
+use std::io;
+use std::process::{Command, ExitStatus, Output};
+use thiserror::Error;
 
+/// Error type for command execution failures
+#[derive(Debug, Error)]
+pub enum CommandError {
+    #[error("Failed to run {command}: {source}")]
+    IoError {
+        command: String,
+        #[source]
+        source: io::Error,
+    },
+
+    #[error("Command {command} failed with status {status}")]
+    FailedStatus { command: String, status: ExitStatus },
+}
+
+/// Trait extension for Command to check output status
 pub trait CommandExt {
-    fn output_checked(&mut self) -> Result<Output>;
+    fn output_checked(&mut self) -> Result<Output, CommandError>;
 }
 
 impl CommandExt for Command {
-    fn output_checked(&mut self) -> Result<Output> {
+    fn output_checked(&mut self) -> Result<Output, CommandError> {
         let command = self.get_program().to_string_lossy().to_string();
 
-        let output = self
-            .output()
-            .with_context(|| format!("Failed to run {command}"))?;
-
-        if !output.status.success() {
-            bail!("Command {command} failed with status {}", output.status);
+        match self.output() {
+            Ok(output) => {
+                if output.status.success() {
+                    Ok(output)
+                } else {
+                    Err(CommandError::FailedStatus {
+                        command,
+                        status: output.status,
+                    })
+                }
+            }
+            Err(source) => Err(CommandError::IoError { command, source }),
         }
-
-        Ok(output)
     }
 }

crates/shared/src/command.rs

@@ -14,3 +14,5 @@ num-bigint.workspace = true
 cairo-lang-casm.workspace = true
 camino.workspace = true
 tracing.workspace = true
+strum_macros.workspace = true
+thiserror.workspace = true

crates/universal-sierra-compiler-api/Cargo.toml

@@ -1,88 +1,72 @@
-use anyhow::Context;
-use std::env;
-use std::ffi::{OsStr, OsString};
-use std::path::PathBuf;
-use std::process::{Command, Stdio};
+use shared::command::{CommandError, CommandExt};
+use std::process::Output;
+use std::{
+    env,
+    ffi::OsStr,
+    process::{Command, Stdio},
+};
+use thiserror::Error;
+
+/// Represents possible errors when working with USC commands.
+
+#[derive(Debug, Error)]
+pub enum USCError {
+    #[error(
+        "`universal-sierra-compiler` binary not available. \
+             Make sure it is installed and available in PATH or set via UNIVERSAL_SIERRA_COMPILER."
+    )]
+    NotFound(#[source] which::Error),
+
+    #[error(
+        "Error while compiling Sierra. \
+             Make sure you have the latest universal-sierra-compiler binary installed. \
+             Contact us if it doesn't help."
+    )]
+    RunFailed(#[source] CommandError),
+}
 
 /// A builder for `universal-sierra-compiler` command invocation.
-#[derive(Clone, Debug, Default)]
-pub struct UniversalSierraCompilerCommand {
-    args: Vec<OsString>,
-    current_dir: Option<PathBuf>,
-    inherit_stderr: bool,
+#[derive(Debug)]
+pub struct USCInternalCommand {
+    inner: Command,
 }
 
-impl UniversalSierraCompilerCommand {
+impl USCInternalCommand {
     /// Creates a default `universal-sierra-compiler` command,
     /// which will look for `universal-sierra-compiler` in `$PATH`
-    #[must_use]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Ensures that `universal-sierra-compiler` binary is available in the system.
-    pub fn ensure_available() -> anyhow::Result<()> {
-        which::which(UniversalSierraCompilerCommand::binary_path())
-            .context("Cannot find `universal-sierra-compiler` binary. \
-                      Make sure you have USC installed https://github.com/software-mansion/universal-sierra-compiler \
-                      and added to PATH (or set at UNIVERSAL_SIERRA_COMPILER env var)"
-            )?;
-        Ok(())
-    }
-
-    /// Current directory of the `universal-sierra-compiler` process.
-    pub fn current_dir(&mut self, path: impl Into<PathBuf>) -> &mut Self {
-        self.current_dir = Some(path.into());
-        self
-    }
-
-    /// Inherit standard error, i.e. show USC errors in this process's standard error.
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.inherit_stderr = true;
-        self
+    pub fn new() -> Result<Self, USCError> {
+        ensure_available()?;
+        let mut cmd = Command::new(binary_path());
+        cmd.stderr(Stdio::inherit());
+        Ok(Self { inner: cmd })
     }
 
     /// Adds an argument to pass to `universal-sierra-compiler`.
-    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
-        self.args.push(arg.as_ref().to_os_string());
-        self
-    }
-
-    /// Adds multiple arguments to pass to `universal-sierra-compiler`.
-    pub fn args<I, S>(&mut self, args: I) -> &mut Self
-    where
-        I: IntoIterator<Item = S>,
-        S: AsRef<OsStr>,
-    {
-        self.args
-            .extend(args.into_iter().map(|s| s.as_ref().to_os_string()));
+    pub fn arg(mut self, arg: impl AsRef<OsStr>) -> Self {
+        self.inner.arg(arg);
         self
     }
 
     /// Build executable `universal-sierra-compiler` command.
     #[must_use]
-    pub fn command(&self) -> Command {
-        let universal_sierra_compiler = UniversalSierraCompilerCommand::binary_path();
-
-        let mut cmd = Command::new(universal_sierra_compiler);
-
-        cmd.args(&self.args);
-
-        if let Some(path) = &self.current_dir {
-            cmd.current_dir(path);
-        }
-
-        if self.inherit_stderr {
-            cmd.stderr(Stdio::inherit());
-        }
-
-        cmd
+    pub fn command(self) -> Command {
+        self.inner
     }
 
-    fn binary_path() -> PathBuf {
-        env::var("UNIVERSAL_SIERRA_COMPILER")
-            .map(PathBuf::from)
-            .ok()
-            .unwrap_or_else(|| PathBuf::from("universal-sierra-compiler"))
+    pub fn run(self) -> Result<Output, USCError> {
+        self.command().output_checked().map_err(USCError::RunFailed)
     }
 }
+
+/// Ensures that `universal-sierra-compiler` binary is available in the system.
+pub fn ensure_available() -> Result<(), USCError> {
+    which::which(binary_path())
+        .map(|_| ())
+        .map_err(USCError::NotFound)
+}
+
+/// Returns the binary path either from env or fallback to default name.
+fn binary_path() -> String {
+    env::var("UNIVERSAL_SIERRA_COMPILER")
+        .unwrap_or_else(|_| "universal-sierra-compiler".to_string())
+}

crates/universal-sierra-compiler-api/src/command.rs

@@ -1,17 +1,15 @@
-use anyhow::{Context, Result, anyhow};
+use crate::command::USCInternalCommand;
+use anyhow::{Result, anyhow};
 use cairo_lang_casm::hints::Hint;
 use camino::Utf8Path;
 use num_bigint::BigInt;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::fmt::Display;
 use std::io::Write;
-use std::str::from_utf8;
+use std::process::Command;
+use strum_macros::Display;
 use tempfile::Builder;
 
-pub use command::*;
-use shared::command::CommandExt;
-
 mod command;
 
 pub type CasmCodeOffset = usize;
@@ -71,38 +69,22 @@ pub fn compile_sierra_at_path<T: UniversalSierraCompilerOutput>(
     sierra_file_path: &Utf8Path,
     sierra_type: &SierraType,
 ) -> Result<T> {
-    let usc_output = UniversalSierraCompilerCommand::new()
-        .inherit_stderr()
-        .args(vec![
-            &("compile-".to_string() + &sierra_type.to_string()),
-            "--sierra-path",
-            sierra_file_path.as_str(),
-        ])
-        .command()
-        .output_checked()
-        .context(
-            "Error while compiling Sierra. \
-        Make sure you have the latest universal-sierra-compiler binary installed. \
-        Contact us if it doesn't help",
-        )?;
+    let usc_output = USCInternalCommand::new()?
+        .arg(format!("compile-{sierra_type}"))
+        .arg("--sierra-path")
+        .arg(sierra_file_path.as_str())
+        .run()?;
 
-    Ok(T::convert(from_utf8(&usc_output.stdout)?.to_string()))
+    Ok(T::convert(String::from_utf8(usc_output.stdout)?))
 }
 
+#[derive(Debug, Display)]
+#[strum(serialize_all = "lowercase")]
 pub enum SierraType {
     Contract,
     Raw,
 }
 
-impl Display for SierraType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                SierraType::Contract => "contract",
-                SierraType::Raw => "raw",
-            }
-        )
-    }
+pub fn version_command() -> Result<Command> {
+    Ok(USCInternalCommand::new()?.arg("--version").command())
 }