feat: let nargo test use the new greybox fuzzer (#8234)

Author: asterite

Cargo.lock

@@ -206,7 +206,8 @@ impl CrateDefMap {
                     match attributes.function().map(|attr| &attr.kind) {
                         Some(FunctionAttributeKind::Test(scope)) => {
                             let location = interner.function_meta(&func_id).name.location;
-                            Some(TestFunction::new(func_id, scope.clone(), location, has_arguments))
+                            let scope = scope.clone();
+                            Some(TestFunction { id: func_id, scope, location, has_arguments })
                         }
                         _ => None,
                     }
@@ -230,7 +231,7 @@ impl CrateDefMap {
                     match attributes.function().map(|attr| &attr.kind) {
                         Some(FunctionAttributeKind::FuzzingHarness(scope)) => {
                             let location = interner.function_meta(&func_id).name.location;
-                            Some(FuzzingHarness::new(func_id, scope.clone(), location))
+                            Some(FuzzingHarness { id: func_id, scope: scope.clone(), location })
                         }
                         _ => None,
                     }
@@ -373,30 +374,13 @@ pub fn parse_file(fm: &FileManager, file_id: FileId) -> (ParsedModule, Vec<Parse
 }
 
 pub struct TestFunction {
-    id: FuncId,
-    scope: TestScope,
-    location: Location,
-    has_arguments: bool,
+    pub id: FuncId,
+    pub scope: TestScope,
+    pub location: Location,
+    pub has_arguments: bool,
 }
 
 impl TestFunction {
-    fn new(id: FuncId, scope: TestScope, location: Location, has_arguments: bool) -> Self {
-        TestFunction { id, scope, location, has_arguments }
-    }
-
-    /// Returns the function id of the test function
-    pub fn get_id(&self) -> FuncId {
-        self.id
-    }
-
-    pub fn file_id(&self) -> FileId {
-        self.location.file
-    }
-
-    pub fn has_arguments(&self) -> bool {
-        self.has_arguments
-    }
-
     /// Returns true if the test function has been specified to fail
     /// This is done by annotating the function with `#[test(should_fail)]`
     /// or `#[test(should_fail_with = "reason")]`
@@ -418,25 +402,12 @@ impl TestFunction {
 }
 
 pub struct FuzzingHarness {
-    id: FuncId,
-    scope: FuzzingScope,
-    location: Location,
+    pub id: FuncId,
+    pub scope: FuzzingScope,
+    pub location: Location,
 }
 
 impl FuzzingHarness {
-    fn new(id: FuncId, scope: FuzzingScope, location: Location) -> Self {
-        FuzzingHarness { id, scope, location }
-    }
-
-    /// Returns the function id of the test function
-    pub fn get_id(&self) -> FuncId {
-        self.id
-    }
-
-    pub fn file_id(&self) -> FileId {
-        self.location.file
-    }
-
     /// Returns true if the fuzzing harness has been specified to fail only under specific reason
     /// This is done by annotating the function with
     /// `#[fuzz(only_fail_with = "reason")]`

compiler/noirc_frontend/src/hir/def_map/mod.rs

@@ -180,7 +180,7 @@ impl Context<'_, '_> {
             .get_all_test_functions(interner)
             .filter_map(|test_function| {
                 let fully_qualified_name =
-                    self.fully_qualified_function_name(crate_id, &test_function.get_id());
+                    self.fully_qualified_function_name(crate_id, &test_function.id);
                 match &pattern {
                     FunctionNameMatch::Anything => Some((fully_qualified_name, test_function)),
                     FunctionNameMatch::Exact(patterns) => patterns
@@ -211,7 +211,7 @@ impl Context<'_, '_> {
             .get_all_fuzzing_harnesses(interner)
             .filter_map(|fuzzing_harness| {
                 let fully_qualified_name =
-                    self.fully_qualified_function_name(crate_id, &fuzzing_harness.get_id());
+                    self.fully_qualified_function_name(crate_id, &fuzzing_harness.id);
                 match &pattern {
                     FunctionNameMatch::Anything => Some((fully_qualified_name, fuzzing_harness)),
                     FunctionNameMatch::Exact(patterns) => patterns

compiler/noirc_frontend/src/hir/mod.rs

@@ -271,6 +271,8 @@ pub struct FuzzedExecutorExecutionConfiguration {
     pub num_threads: usize,
     /// Maximum time in seconds to spend fuzzing (default: no timeout)
     pub timeout: u64,
+    /// Whether to output progress to stdout or not.
+    pub show_progress: bool,
 }
 
 pub enum FuzzedExecutorFailureConfiguration {
@@ -321,6 +323,9 @@ pub struct FuzzedExecutor<E, F> {
     /// Number of threads to use
     num_threads: usize,
 
+    /// Whether to output progress to stdout or not.
+    show_progress: bool,
+
     /// Determines what is considered a failure during execution
     failure_configuration: FuzzedExecutorFailureConfiguration,
 
@@ -391,6 +396,7 @@ impl<
             package_name: package_name.to_string(),
             function_name: function_name.to_string(),
             num_threads: fuzz_execution_config.num_threads,
+            show_progress: fuzz_execution_config.show_progress,
             failure_configuration,
             corpus_dir: PathBuf::from(
                 folder_configuration.corpus_dir.unwrap_or(DEFAULT_CORPUS_FOLDER.to_string()),
@@ -530,17 +536,19 @@ impl<
             minimized_corpus_path =
                 minimized_corpus.as_ref().unwrap().get_corpus_storage_path().to_path_buf();
         }
-        let _ = display_starting_info(
-            self.minimize_corpus,
-            seed,
-            starting_corpus_ids.len(),
-            self.num_threads,
-            &self.package_name,
-            &self.function_name,
-            corpus.get_corpus_storage_path(),
-            &minimized_corpus_path,
-            abi_change_detected,
-        );
+        if self.show_progress {
+            let _ = display_starting_info(
+                self.minimize_corpus,
+                seed,
+                starting_corpus_ids.len(),
+                self.num_threads,
+                &self.package_name,
+                &self.function_name,
+                corpus.get_corpus_storage_path(),
+                &minimized_corpus_path,
+                abi_change_detected,
+            );
+        }
 
         // Generate the default input (it is needed if the corpus is empty)
         let default_map = self.mutator.generate_default_input_map();
@@ -745,7 +753,9 @@ impl<
                 all_fuzzing_results.iter().find(|fast_result| fast_result.failed())
             {
                 self.metrics.set_active_corpus_size(corpus.get_testcase_count());
-                let _ = display_metrics(&self.metrics);
+                if self.show_progress {
+                    let _ = display_metrics(&self.metrics);
+                }
                 break individual_failing_result.outcome().clone();
             }
 
@@ -934,7 +944,9 @@ impl<
             // If we've found something, return
             if let Some(result) = failing_result {
                 self.metrics.set_active_corpus_size(corpus.get_testcase_count());
-                let _ = display_metrics(&self.metrics);
+                if self.show_progress {
+                    let _ = display_metrics(&self.metrics);
+                }
                 break result;
             }
             if time_tracker.elapsed() - last_metric_check
@@ -943,7 +955,9 @@ impl<
                 // Update and display metrics
                 self.metrics.set_active_corpus_size(corpus.get_testcase_count());
                 self.metrics.set_last_round_update_time(updating_time);
-                let _ = display_metrics(&self.metrics);
+                if self.show_progress {
+                    let _ = display_metrics(&self.metrics);
+                }
                 self.metrics.refresh_round();
                 last_metric_check = time_tracker.elapsed();
                 // Check if we've exceeded the timeout

tooling/greybox_fuzzer/src/lib.rs

@@ -225,7 +225,7 @@ fn get_package_tests_in_crate(
     let package_tests: Vec<_> = tests
         .into_iter()
         .map(|(func_name, test_function)| {
-            let location = context.function_meta(&test_function.get_id()).name.location;
+            let location = context.function_meta(&test_function.id).name.location;
             let file_id = location.file;
             let file_path = fm.path(file_id).expect("file must exist to contain tests");
             let range =

tooling/lsp/src/lib.rs

@@ -100,7 +100,7 @@ pub(crate) fn collect_lenses_for_package(
     let tests =
         context.get_all_test_functions_in_crate_matching(&crate_id, &FunctionNameMatch::Anything);
     for (func_name, test_function) in tests {
-        let location = context.function_meta(&test_function.get_id()).name.location;
+        let location = context.function_meta(&test_function.id).name.location;
         let file_id = location.file;
 
         // Ignore diagnostics for any file that wasn't the file we saved

tooling/lsp/src/requests/code_lens_request.rs

@@ -28,8 +28,6 @@ tracing.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 walkdir = "2.5.0"
-noir_fuzzer = { workspace = true }
-proptest = { workspace = true }
 noir_greybox_fuzzer = { workspace = true }
 
 # Some dependencies are optional so we can compile to Wasm.

tooling/nargo/Cargo.toml

@@ -58,12 +58,8 @@ pub fn get_test_function_for_debug(
         }
     };
 
-    let test_function_has_arguments = !context
-        .def_interner
-        .function_meta(&test_function.get_id())
-        .function_signature()
-        .0
-        .is_empty();
+    let test_function_has_arguments =
+        !context.def_interner.function_meta(&test_function.id).function_signature().0.is_empty();
 
     if test_function_has_arguments {
         return Err(String::from("Cannot debug tests with arguments"));
@@ -78,7 +74,7 @@ pub fn compile_test_fn_for_debugging(
     compile_options: CompileOptions,
 ) -> Result<CompiledProgram, noirc_driver::CompileError> {
     let compiled_program =
-        compile_no_check(context, &compile_options, test_def.function.get_id(), None, false)?;
+        compile_no_check(context, &compile_options, test_def.function.id, None, false)?;
     let expression_width =
         get_target_width(package.expression_width, compile_options.expression_width);
     let compiled_program = transform_program(compiled_program, expression_width);