produce optimized wasm in addition to regular

Author: BlaineHeffron

cmd/soroban-cli/src/commands/contract/build.rs

@@ -31,6 +31,7 @@ use crate::{commands::global, print::Print};
 /// To view the commands that will be executed, without executing them, use the
 /// --print-commands-only option.
 #[derive(Parser, Debug, Clone)]
+#[allow(clippy::struct_excessive_bools)]
 pub struct Cmd {
     /// Path to Cargo.toml
     #[arg(long)]
@@ -46,25 +47,6 @@ pub struct Cmd {
     /// Build with the list of features activated, space or comma separated
     #[arg(long, help_heading = "Features")]
     pub features: Option<String>,
-    #[clap(flatten)]
-    pub feature_flags: FeatureFlags,
-    #[clap(flatten)]
-    pub build_options: BuildOptions,
-    /// Directory to copy wasm files to
-    ///
-    /// If provided, wasm files can be found in the cargo target directory, and
-    /// the specified directory.
-    ///
-    /// If ommitted, wasm files are written only to the cargo target directory.
-    #[arg(long)]
-    pub out_dir: Option<std::path::PathBuf>,
-    /// Add key-value to contract meta (adds the meta to the `contractmetav0` custom section)
-    #[arg(long, num_args=1, value_parser=parse_meta_arg, action=clap::ArgAction::Append, help_heading = "Metadata")]
-    pub meta: Vec<(String, String)>,
-}
-
-#[derive(Debug, Clone, Parser)]
-pub struct FeatureFlags {
     /// Build with the all features activated
     #[arg(
         long,
@@ -76,15 +58,23 @@ pub struct FeatureFlags {
     /// Build with the default feature not activated
     #[arg(long, help_heading = "Features")]
     pub no_default_features: bool,
-}
-#[derive(Debug, Clone, Parser)]
-pub struct BuildOptions {
     /// Additionally optimize the built WASM file(s)
     #[arg(long, help_heading = "Other")]
     pub optimize: bool,
+    /// Directory to copy wasm files to
+    ///
+    /// If provided, wasm files can be found in the cargo target directory, and
+    /// the specified directory.
+    ///
+    /// If ommitted, wasm files are written only to the cargo target directory.
+    #[arg(long)]
+    pub out_dir: Option<std::path::PathBuf>,
     /// Print commands to build without executing them
     #[arg(long, conflicts_with = "out_dir", help_heading = "Other")]
     pub print_commands_only: bool,
+    /// Add key-value to contract meta (adds the meta to the `contractmetav0` custom section)
+    #[arg(long, num_args=1, value_parser=parse_meta_arg, action=clap::ArgAction::Append, help_heading = "Metadata")]
+    pub meta: Vec<(String, String)>,
 }
 
 fn parse_meta_arg(s: &str) -> Result<(String, String), Error> {
@@ -171,10 +161,10 @@ impl Cmd {
             } else {
                 cmd.arg(format!("--profile={}", self.profile));
             }
-            if self.feature_flags.all_features {
+            if self.all_features {
                 cmd.arg("--all-features");
             }
-            if self.feature_flags.no_default_features {
+            if self.no_default_features {
                 cmd.arg("--no-default-features");
             }
             if let Some(features) = self.features() {
@@ -206,7 +196,7 @@ impl Cmd {
             );
             let cmd_str = cmd_str_parts.join(" ");
 
-            if self.build_options.print_commands_only {
+            if self.print_commands_only {
                 println!("{cmd_str}");
             } else {
                 print.infoln(cmd_str);
@@ -247,24 +237,20 @@ impl Cmd {
         };
 
         #[cfg(feature = "opt")]
-        let mut cost_savings = None;
+        let mut optimized_path = None;
         #[cfg(not(feature = "opt"))]
-        let cost_savings = None;
+        let optimized_path = None;
 
-        if self.build_options.optimize {
+        if self.optimize {
             #[cfg(feature = "opt")]
             {
                 use crate::wasm::Args as WasmArgs;
-                let orig_size = fs::metadata(&final_path).map(|m| m.len()).unwrap_or(0);
-                let tmp_optimized = final_path.with_extension("optimized.wasm");
+                let optimized_file_path = final_path.with_extension("optimized.wasm");
                 let wasm_args = WasmArgs {
                     wasm: final_path.clone(),
                 };
-                wasm_args.optimize(&tmp_optimized)?;
-                let opt_size = fs::metadata(&tmp_optimized).map(|m| m.len()).unwrap_or(0);
-                // Overwrite original file with optimized artifact:
-                fs::rename(&tmp_optimized, &final_path).map_err(Error::WritingWasmFile)?;
-                cost_savings = Some((orig_size, opt_size));
+                wasm_args.optimize(&optimized_file_path)?;
+                optimized_path = Some(optimized_file_path);
             }
             #[cfg(not(feature = "opt"))]
             {
@@ -274,12 +260,7 @@ impl Cmd {
             }
         }
 
-        Self::print_build_summary(
-            print,
-            &final_path,
-            self.build_options.optimize,
-            cost_savings,
-        )?;
+        Self::print_build_summary(print, &final_path, optimized_path.as_ref())?;
 
         Ok(())
     }
@@ -385,26 +366,40 @@ impl Cmd {
     fn print_build_summary(
         print: &Print,
         target_file_path: &PathBuf,
-        optimized: bool,
-        cost_savings: Option<(u64, u64)>,
+        optimized_path: Option<&PathBuf>,
     ) -> Result<(), Error> {
-        if optimized {
+        if optimized_path.is_some() {
             print.infoln("Build Summary (Optimized):");
         } else {
             print.infoln("Build Summary:");
         }
 
-        Self::print_file_summary(print, "Wasm File", target_file_path)?;
+        Self::print_file_summary(print, "Wasm File", target_file_path, false, None)?;
+
+        if let Some(optimized_path) = optimized_path {
+            let orig_size = fs::metadata(target_file_path).map(|m| m.len()).unwrap_or(0);
+            let opt_size = fs::metadata(optimized_path).map(|m| m.len()).unwrap_or(0);
 
-        if let Some((before, after)) = cost_savings {
-            print.blankln(format!("Optimized: {before} → {after} bytes"));
+            Self::print_file_summary(
+                print,
+                "Optimized Wasm File",
+                optimized_path,
+                true,
+                Some((orig_size, opt_size)),
+            )?;
         }
 
         print.checkln("Build Complete");
         Ok(())
     }
 
-    fn print_file_summary(print: &Print, label: &str, file_path: &PathBuf) -> Result<(), Error> {
+    fn print_file_summary(
+        print: &Print,
+        label: &str,
+        file_path: &PathBuf,
+        show_size: bool,
+        size_savings: Option<(u64, u64)>,
+    ) -> Result<(), Error> {
         let rel_file_path = file_path
             .strip_prefix(env::current_dir().unwrap())
             .unwrap_or(file_path);
@@ -416,31 +411,44 @@ impl Cmd {
             "Wasm Hash: {}",
             hex::encode(Sha256::digest(&wasm_bytes))
         ));
-        print.blankln(format!("Wasm Size: {} bytes", wasm_bytes.len()));
-
-        let parser = wasmparser::Parser::new(0);
-        let export_names: Vec<&str> = parser
-            .parse_all(&wasm_bytes)
-            .filter_map(Result::ok)
-            .filter_map(|payload| {
-                if let wasmparser::Payload::ExportSection(exports) = payload {
-                    Some(exports)
-                } else {
-                    None
+
+        if show_size {
+            if let Some((orig_size, opt_size)) = size_savings {
+                let savings = orig_size - opt_size;
+                print.blankln(format!(
+                    "Wasm Size: {opt_size} bytes (reduced by {savings} bytes)",
+                ));
+            } else {
+                print.blankln(format!("Wasm Size: {} bytes", wasm_bytes.len()));
+            }
+        }
+
+        // Only show exported functions for non-optimized files
+        if !show_size || size_savings.is_none() {
+            let parser = wasmparser::Parser::new(0);
+            let export_names: Vec<&str> = parser
+                .parse_all(&wasm_bytes)
+                .filter_map(Result::ok)
+                .filter_map(|payload| {
+                    if let wasmparser::Payload::ExportSection(exports) = payload {
+                        Some(exports)
+                    } else {
+                        None
+                    }
+                })
+                .flatten()
+                .filter_map(Result::ok)
+                .filter(|export| matches!(export.kind, wasmparser::ExternalKind::Func))
+                .map(|export| export.name)
+                .sorted()
+                .collect();
+            if export_names.is_empty() {
+                print.blankln("Exported Functions: None found");
+            } else {
+                print.blankln(format!("Exported Functions: {} found", export_names.len()));
+                for name in export_names {
+                    print.blankln(format!("  • {name}"));
                 }
-            })
-            .flatten()
-            .filter_map(Result::ok)
-            .filter(|export| matches!(export.kind, wasmparser::ExternalKind::Func))
-            .map(|export| export.name)
-            .sorted()
-            .collect();
-        if export_names.is_empty() {
-            print.blankln("Exported Functions: None found");
-        } else {
-            print.blankln(format!("Exported Functions: {} found", export_names.len()));
-            for name in export_names {
-                print.blankln(format!("  • {name}"));
             }
         }