Refactor execute adds

Author: maciektr

extensions/scarb-execute/src/lib.rs

@@ -26,7 +26,7 @@ use create_output_dir::create_output_dir;
 use indoc::formatdoc;
 use num_bigint::BigInt;
 use scarb_extensions_cli::execute::{
-    Args, BuildTargetSpecifier, ExecutionArgs, OutputFormat, ProgramArguments,
+    Args, BuildTargetSpecifier, ExecutionArgs, ExecutionTarget, OutputFormat, ProgramArguments,
 };
 use scarb_fs_utils::canonicalize_utf8;
 use scarb_metadata::{Metadata, MetadataCommand, PackageMetadata, ScarbCommand, TargetMetadata};
@@ -207,11 +207,12 @@ fn execute_standalone(
 
 fn build_cairo_run_config(
     output: &OutputFormat,
+    target: &ExecutionTarget,
     args: &ExecutionArgs,
 ) -> Result<CairoRunConfig<'static>> {
     let relocate_mem =
         output.is_standard() || args.run.print_resource_usage || args.run.save_profiler_trace_data;
-    if args.run.target.is_bootloader() {
+    if target.is_bootloader() {
         Ok(get_cairo_run_config(
             &None,
             args.run.layout,
@@ -243,8 +244,18 @@ pub fn execute(
     args: &ExecutionArgs,
     ui: &Ui,
 ) -> Result<()> {
-    let output = args.run.output.as_ref().cloned().unwrap_or_default();
-    output.validate(&args.run.target)?;
+    let output = args
+        .run
+        .output
+        .as_ref()
+        .cloned()
+        .unwrap_or(OutputFormat::None);
+    let target = args
+        .run
+        .target
+        .clone()
+        .unwrap_or(ExecutionTarget::Standalone);
+    output.validate(&target)?;
 
     if !args.no_build {
         let filter = PackagesFilter::generate_for::<Metadata>([package.clone()].iter());
@@ -289,9 +300,9 @@ pub fn execute(
     create_output_dir(output_dir.as_std_path())?;
 
     let execution_output_dir = get_or_create_output_dir(&output_dir)?;
-    let cairo_run_config = build_cairo_run_config(&output, args)?;
+    let cairo_run_config = build_cairo_run_config(&output, &target, args)?;
 
-    let (mut runner, hint_processor) = if args.run.target.is_bootloader() {
+    let (mut runner, hint_processor) = if target.is_bootloader() {
         execute_bootloader(
             executable_path,
             &cairo_run_config,
@@ -376,7 +387,7 @@ pub fn execute(
             .expect("Missing or invalid program_offset in debug info")
             as usize;
         let call_trace = build_profiler_call_trace(
-            &args.run.target,
+            &target,
             runner.relocated_trace.clone(),
             execution_resources.expect("Failed to obtain execution resources"),
             &tracked_resource,

extensions/scarb-prove/src/main.rs

@@ -8,12 +8,12 @@ use clap::Parser;
 use create_output_dir::create_output_dir;
 use indoc::{formatdoc, indoc};
 use mimalloc::MiMalloc;
-use scarb_extensions_cli::execute::for_proving::ToArgs;
+use scarb_extensions_cli::execute::{ExecutionTarget, OutputFormat, ToArgs};
 use scarb_extensions_cli::prove::Args;
 use scarb_metadata::{Metadata, MetadataCommand, ScarbCommand};
+use scarb_ui::Ui;
 use scarb_ui::args::{PackagesFilter, ToEnvVars};
 use scarb_ui::components::Status;
-use scarb_ui::{OutputFormat, Ui};
 use std::fs;
 use std::process::ExitCode;
 use std::{env, io};
@@ -27,7 +27,7 @@ const MAX_ITERATION_COUNT: usize = 10000;
 
 fn main() -> ExitCode {
     let args = Args::parse();
-    let ui = Ui::new(args.verbose.clone().into(), OutputFormat::Text);
+    let ui = Ui::new(args.verbose.clone().into(), scarb_ui::OutputFormat::Text);
 
     match main_inner(args, ui.clone()) {
         Ok(()) => ExitCode::SUCCESS,
@@ -72,18 +72,28 @@ fn main_inner(args: Args, ui: Ui) -> Result<()> {
 
             let filter = PackagesFilter::generate_for::<Metadata>(vec![package.clone()].iter());
             ensure!(
-                args.execute_args.run.target.is_bootloader(),
+                args.execute_args
+                    .run
+                    .target
+                    .as_ref()
+                    .map(|t| t.is_bootloader())
+                    .unwrap_or(true),
                 "only bootloader execution can be proven with `scarb prove` command"
             );
-            ScarbCommand::new()
-                .arg("execute")
+            let mut cmd = ScarbCommand::new();
+            cmd.arg("execute")
                 .args(args.execute_args.to_args())
                 .env("SCARB_EXECUTION_ID", execution_id.to_string())
                 .env("SCARB_PACKAGES_FILTER", filter.to_env())
                 .env("SCARB_UI_VERBOSITY", ui.verbosity().to_string())
-                .envs(args.execute_args.features.clone().to_env_vars())
-                .run()
-                .with_context(|| "execution failed")?;
+                .envs(args.execute_args.features.clone().to_env_vars());
+            if args.execute_args.run.target.is_none() {
+                cmd.arg(format!("--target={}", ExecutionTarget::Bootloader));
+            }
+            if args.execute_args.run.output.is_none() {
+                cmd.arg(format!("--output={}", OutputFormat::Standard));
+            }
+            cmd.run().with_context(|| "execution failed")?;
 
             execution_id
         }

scarb/src/internal/to_version.rs

@@ -14,7 +14,7 @@ impl ToVersion for Version {
 impl ToVersion for &str {
     fn to_version(self) -> Result<Version> {
         Version::parse(self.trim())
-            .map_err(|_| anyhow::format_err!("cannot parse '{}' as a semver", self))
+            .map_err(|_| anyhow::format_err!("cannot parse '{self}' as a semver",))
     }
 }
 

utils/scarb-extensions-cli/Cargo.toml

@@ -16,21 +16,15 @@ scarb-ui = { path = "../scarb-ui", optional = true }
 cairo-language-server = []
 cairo-test = ["dep:scarb-ui"]
 doc = ["dep:scarb-ui"]
-execute_unchecked = [
-    "dep:anyhow",
-    "dep:camino",
-    "dep:scarb-ui"
-]
 execute = [
-    "execute_unchecked",
     "dep:anyhow",
     "dep:camino",
     "dep:cairo-vm",
     "dep:scarb-ui",
     "cairo-vm/clap"
 ]
 mdbook = ["dep:camino", "dep:scarb-ui"]
-prove = ["execute_unchecked", "dep:scarb-ui"]
+prove = ["execute", "dep:scarb-ui"]
 verify = ["dep:camino", "dep:scarb-ui"]
 default = [
     "cairo-language-server",

…ensions-cli/src/execute/for_execution.rs utils/scarb-extensions-cli/src/execute.rsutils/scarb-extensions-cli/src/execute/for_execution.rs renamed to utils/scarb-extensions-cli/src/execute.rs utils/scarb-extensions-cli/src/execute/for_execution.rs renamed to utils/scarb-extensions-cli/src/execute.rs

@@ -112,8 +112,8 @@ pub struct RunArgs {
     pub output: Option<OutputFormat>,
 
     /// Execution target.
-    #[arg(long, default_value = "standalone")]
-    pub target: ExecutionTarget,
+    #[arg(long)]
+    pub target: Option<ExecutionTarget>,
 
     /// Whether to print the program outputs.
     #[arg(long, default_value_t = false)]
@@ -148,8 +148,10 @@ impl ToArgs for RunArgs {
             args.push("--output".to_string());
             args.push(output.to_string());
         }
-        args.push("--target".to_string());
-        args.push(target.to_string());
+        if let Some(target) = target {
+            args.push("--target".to_string());
+            args.push(target.to_string());
+        }
         if *print_program_output {
             args.push("--print-program-output".to_string());
         }
@@ -199,14 +201,13 @@ impl ToArgs for ProgramArguments {
 }
 
 /// Output format for the execution
-#[derive(ValueEnum, Clone, Debug, Default)]
+#[derive(ValueEnum, Clone, Debug)]
 pub enum OutputFormat {
     /// Output in standard format
     Standard,
     /// Output in Cairo PIE (Program Independent Execution) format
     CairoPie,
     /// No output
-    #[default]
     None,
 }