Use debugging in forge without a feature flag (#3289)

Related #3164

commit-id:fb008c1d

---

**Stack**:
- #3319
- #3318
- #3289 ⬅


⚠️ *Part of a stack created by [spr](https://github.com/ejoffe/spr). Do
not merge manually using the UI - doing so may have unexpected results.*

Author: ksew1

crates/forge-runner/Cargo.toml

@@ -46,6 +46,3 @@ universal-sierra-compiler-api = { path = "../universal-sierra-compiler-api" }
 which.workspace = true
 sanitize-filename.workspace = true
 clap.workspace = true
-
-[features]
-debugging = []

crates/forge-runner/src/debugging.rs

@@ -0,0 +1,39 @@
+use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
+use cheatnet::state::CallTrace;
+use clap::ValueEnum;
+
+/// Trace verbosity level.
+#[derive(ValueEnum, Debug, Clone, Copy)]
+pub enum TraceVerbosity {
+    /// Display test name, contract name and selector.
+    Minimal,
+    /// Display test name, contract name, selector, calldata and call result.
+    Standard,
+    /// Display everything.
+    Detailed,
+}
+
+impl From<TraceVerbosity> for debugging::Verbosity {
+    fn from(verbosity: TraceVerbosity) -> Self {
+        match verbosity {
+            TraceVerbosity::Minimal => debugging::Verbosity::Minimal,
+            TraceVerbosity::Standard => debugging::Verbosity::Standard,
+            TraceVerbosity::Detailed => debugging::Verbosity::Detailed,
+        }
+    }
+}
+
+#[must_use]
+pub fn build_debugging_trace(
+    call_trace: &CallTrace,
+    contracts_data: &ContractsData,
+    trace_verbosity: Option<TraceVerbosity>,
+    test_name: String,
+) -> Option<debugging::Trace> {
+    Some(debugging::Trace::new(
+        call_trace,
+        contracts_data,
+        trace_verbosity?.into(),
+        test_name,
+    ))
+}

crates/forge-runner/src/lib.rs

@@ -1,4 +1,5 @@
 use crate::coverage_api::run_coverage;
+use crate::debugging::TraceVerbosity;
 use crate::forge_config::{ExecutionDataToSave, ForgeConfig, TestRunnerConfig};
 use crate::running::{run_fuzz_test, run_test};
 use crate::test_case_summary::TestCaseSummary;
@@ -33,6 +34,7 @@ pub mod test_case_summary;
 pub mod test_target_summary;
 
 pub mod backtrace;
+pub mod debugging;
 mod gas;
 pub mod printing;
 pub mod running;
@@ -103,6 +105,7 @@ pub fn run_for_test_case(
     forge_config: Arc<ForgeConfig>,
     versioned_program_path: Arc<Utf8PathBuf>,
     send: Sender<()>,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> JoinHandle<Result<AnyTestCaseSummary>> {
     if case.config.fuzzer_config.is_none() {
         tokio::task::spawn(async move {
@@ -112,6 +115,7 @@ pub fn run_for_test_case(
                 forge_config.test_runner_config.clone(),
                 versioned_program_path,
                 send,
+                trace_verbosity,
             )
             .await?;
             Ok(AnyTestCaseSummary::Single(res))
@@ -124,6 +128,7 @@ pub fn run_for_test_case(
                 forge_config.test_runner_config.clone(),
                 versioned_program_path,
                 send,
+                trace_verbosity,
             )
             .await??;
             Ok(AnyTestCaseSummary::Fuzzing(res))
@@ -137,6 +142,7 @@ fn run_with_fuzzing(
     test_runner_config: Arc<TestRunnerConfig>,
     versioned_program_path: Arc<Utf8PathBuf>,
     send: Sender<()>,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> JoinHandle<Result<TestCaseSummary<Fuzzing>>> {
     tokio::task::spawn(async move {
         if send.is_closed() {
@@ -169,6 +175,7 @@ fn run_with_fuzzing(
                 send.clone(),
                 fuzzing_send.clone(),
                 rng.clone(),
+                trace_verbosity,
             ));
         }
 

crates/forge-runner/src/running.rs

@@ -62,6 +62,7 @@ mod hints;
 mod syscall_handler;
 pub mod with_config;
 
+use crate::debugging::{TraceVerbosity, build_debugging_trace};
 use crate::running::syscall_handler::build_syscall_handler;
 pub use syscall_handler::has_segment_arena;
 pub use syscall_handler::syscall_handler_offset;
@@ -73,6 +74,7 @@ pub fn run_test(
     test_runner_config: Arc<TestRunnerConfig>,
     versioned_program_path: Arc<Utf8PathBuf>,
     send: Sender<()>,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> JoinHandle<TestCaseSummary<Single>> {
     tokio::task::spawn_blocking(move || {
         // Due to the inability of spawn_blocking to be abruptly cancelled,
@@ -100,10 +102,12 @@ pub fn run_test(
             &case,
             &test_runner_config.contracts_data,
             &versioned_program_path,
+            trace_verbosity,
         )
     })
 }
 
+#[expect(clippy::too_many_arguments)]
 pub(crate) fn run_fuzz_test(
     case: Arc<TestCaseWithResolvedConfig>,
     casm_program: Arc<AssembledProgramWithDebugInfo>,
@@ -112,6 +116,7 @@ pub(crate) fn run_fuzz_test(
     send: Sender<()>,
     fuzzing_send: Sender<()>,
     rng: Arc<Mutex<StdRng>>,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> JoinHandle<TestCaseSummary<Single>> {
     tokio::task::spawn_blocking(move || {
         // Due to the inability of spawn_blocking to be abruptly cancelled,
@@ -140,6 +145,7 @@ pub(crate) fn run_fuzz_test(
             &case,
             &test_runner_config.contracts_data,
             &versioned_program_path,
+            trace_verbosity,
         )
     })
 }
@@ -413,6 +419,7 @@ fn extract_test_case_summary(
     case: &TestCaseWithResolvedConfig,
     contracts_data: &ContractsData,
     versioned_program_path: &Utf8Path,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> TestCaseSummary<Single> {
     match run_result {
         Ok(run_result) => match run_result {
@@ -421,6 +428,7 @@ fn extract_test_case_summary(
                 case,
                 contracts_data,
                 versioned_program_path,
+                trace_verbosity,
             ),
             RunResult::Error(run_error) => {
                 let mut message = format!(
@@ -444,14 +452,12 @@ fn extract_test_case_summary(
                     }),
                     fuzzer_args: run_error.fuzzer_args,
                     test_statistics: (),
-                    debugging_trace: cfg!(feature = "debugging").then(|| {
-                        debugging::Trace::new(
-                            &run_error.call_trace.borrow(),
-                            contracts_data,
-                            debugging::Verbosity::Detailed,
-                            case.name.clone(),
-                        )
-                    }),
+                    debugging_trace: build_debugging_trace(
+                        &run_error.call_trace.borrow(),
+                        contracts_data,
+                        trace_verbosity,
+                        case.name.clone(),
+                    ),
                 }
             }
         },

crates/forge-runner/src/test_case_summary.rs

@@ -1,5 +1,6 @@
 use crate::backtrace::{add_backtrace_footer, get_backtrace, is_backtrace_enabled};
 use crate::build_trace_data::build_profiler_call_trace;
+use crate::debugging::{TraceVerbosity, build_debugging_trace};
 use crate::expected_result::{ExpectedPanicValue, ExpectedTestResult};
 use crate::gas::check_available_gas;
 use crate::package_tests::with_config_resolved::TestCaseWithResolvedConfig;
@@ -320,17 +321,16 @@ impl TestCaseSummary<Single> {
         test_case: &TestCaseWithResolvedConfig,
         contracts_data: &ContractsData,
         versioned_program_path: &Utf8Path,
+        trace_verbosity: Option<TraceVerbosity>,
     ) -> Self {
         let name = test_case.name.clone();
 
-        let debugging_trace = cfg!(feature = "debugging").then(|| {
-            debugging::Trace::new(
-                &call_trace.borrow(),
-                contracts_data,
-                debugging::Verbosity::Detailed,
-                name.clone(),
-            )
-        });
+        let debugging_trace = build_debugging_trace(
+            &call_trace.borrow(),
+            contracts_data,
+            trace_verbosity,
+            name.clone(),
+        );
 
         match status {
             RunStatus::Success(data) => match &test_case.config.expected_result {

crates/forge/Cargo.toml

@@ -10,7 +10,7 @@ smoke = []
 scarb_2_9_1 = []
 scarb_since_2_10 = []
 no_scarb_installed = []
-debugging = ["forge_runner/debugging"]
+debugging = []
 assert_non_exact_gas = ["test_utils/assert_non_exact_gas"]
 supports-panic-backtrace = []
 

crates/forge/src/lib.rs

@@ -5,6 +5,7 @@ use camino::Utf8PathBuf;
 use clap::{CommandFactory, Parser, Subcommand, ValueEnum};
 use derive_more::Display;
 use forge_runner::CACHE_DIR;
+use forge_runner::debugging::TraceVerbosity;
 use forge_runner::forge_config::ForgeTrackedResource;
 use run_tests::workspace::run_for_workspace;
 use scarb_api::{ScarbCommand, metadata::MetadataCommandExt};
@@ -140,6 +141,11 @@ enum ColorOption {
 pub struct TestArgs {
     /// Name used to filter tests
     test_filter: Option<String>,
+
+    /// Trace verbosity level
+    #[arg(long)]
+    trace_verbosity: Option<TraceVerbosity>,
+
     /// Use exact matches for `test_filter`
     #[arg(short, long)]
     exact: bool,

crates/forge/src/run_tests/package.rs

@@ -22,6 +22,7 @@ use anyhow::Result;
 use camino::{Utf8Path, Utf8PathBuf};
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use configuration::load_package_config;
+use forge_runner::debugging::TraceVerbosity;
 use forge_runner::{
     forge_config::ForgeConfig,
     package_tests::{raw::TestTargetRaw, with_config_resolved::TestTargetWithResolvedConfig},
@@ -133,6 +134,7 @@ pub async fn run_for_package(
         package_name,
     }: RunForPackageArgs,
     block_number_map: &mut BlockNumberMap,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> Result<Vec<TestTargetSummary>> {
     let mut test_targets = test_package_with_config_resolved(
         test_targets,
@@ -163,7 +165,8 @@ pub async fn run_for_package(
 
         let forge_config = forge_config.clone();
 
-        let summary = run_for_test_target(test_target, forge_config, &tests_filter).await?;
+        let summary =
+            run_for_test_target(test_target, forge_config, &tests_filter, trace_verbosity).await?;
 
         match summary {
             TestTargetRunResult::Ok(summary) => {

crates/forge/src/run_tests/test_target.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use forge_runner::debugging::TraceVerbosity;
 use forge_runner::{
     TestCaseFilter,
     forge_config::ForgeConfig,
@@ -23,6 +24,7 @@ pub async fn run_for_test_target(
     tests: TestTargetWithResolvedConfig,
     forge_config: Arc<ForgeConfig>,
     tests_filter: &impl TestCaseFilter,
+    trace_verbosity: Option<TraceVerbosity>,
 ) -> Result<TestTargetRunResult> {
     let casm_program = tests.casm_program.clone();
 
@@ -55,6 +57,7 @@ pub async fn run_for_test_target(
             forge_config.clone(),
             tests.sierra_program_path.clone(),
             send.clone(),
+            trace_verbosity,
         ));
     }
 

crates/forge/src/run_tests/workspace.rs

@@ -69,6 +69,7 @@ pub async fn run_for_workspace(args: TestArgs) -> Result<ExitStatus> {
 
     let workspace_root = &scarb_metadata.workspace.root;
     let cache_dir = workspace_root.join(CACHE_DIR);
+    let trace_verbosity = args.trace_verbosity;
 
     for package in packages {
         env::set_current_dir(&package.root)?;
@@ -81,7 +82,8 @@ pub async fn run_for_workspace(args: TestArgs) -> Result<ExitStatus> {
             &artifacts_dir_path,
         )?;
 
-        let tests_file_summaries = run_for_package(args, &mut block_number_map).await?;
+        let tests_file_summaries =
+            run_for_package(args, &mut block_number_map, trace_verbosity).await?;
 
         all_failed_tests.extend(extract_failed_tests(tests_file_summaries));
     }

crates/forge/test_utils/src/running_tests.rs

@@ -80,6 +80,7 @@ pub fn run_test_case(
             fork_targets: vec![],
         },
         &mut BlockNumberMap::default(),
+        Option::default(),
     ))
     .expect("Runner fail")
 }