chore: Accept optional test path for emitting integration tests

compiler/noirc_frontend/src/test_utils.rs

@@ -66,7 +66,7 @@ pub(crate) fn get_program<'a, 'b>(
     let allow_parser_errors = false;
     get_program_with_options(
         src,
-        test_path,
+        Some(test_path),
         expect,
         allow_parser_errors,
         FrontendOptions::test_default(),
@@ -82,9 +82,13 @@ pub enum Expect {
 /// Compile a program.
 ///
 /// The stdlib is not available for these snippets.
+///
+/// An optional test path is supplied as an argument.
+/// The existence of a test path indicates that we want to emit integration tests
+/// for the supplied program as well.
 pub(crate) fn get_program_with_options(
     src: &str,
-    test_path: &str,
+    test_path: Option<&str>,
     expect: Expect,
     allow_parser_errors: bool,
     options: FrontendOptions,
@@ -136,7 +140,10 @@ pub(crate) fn get_program_with_options(
         ));
     }
 
-    emit_compile_test(test_path, src, expect);
+    if let Some(test_path) = test_path {
+        emit_compile_test(test_path, src, expect);
+    }
+
     (program, context, errors)
 }
 
@@ -164,7 +171,6 @@ fn emit_compile_test(test_path: &str, src: &str, mut expect: Expect) {
     let error_to_warn_cases = [
         "cast_256_to_u8_size_checks",
         "enums_errors_on_unspecified_unstable_enum",
-        "immutable_references_without_ownership_feature",
         "imports_warns_on_use_of_private_exported_item",
         "metaprogramming_does_not_fail_to_parse_macro_on_parser_warning",
         "resolve_unused_var",

compiler/noirc_frontend/src/tests.rs

@@ -37,7 +37,7 @@
 
 pub(crate) fn get_program_using_features(
     src: &str,
-    test_path: &str,
+    test_path: Option<&str>,
     expect: Expect,
     features: &[UnstableFeature],
 ) -> (ParsedModule, Context<'static, 'static>, Vec<CompilationError>) {
@@ -74,7 +74,7 @@
 ///
 /// this method will check that compiling the program without those error markers
 /// will produce errors at those locations and with/ those messages.
-fn check_errors(src: &str, test_path: &str) {
+fn check_errors(src: &str, test_path: Option<&str>) {
     let allow_parser_errors = false;
     let monomorphize = false;
     check_errors_with_options(
@@ -86,7 +86,7 @@
     );
 }
 
-fn check_errors_using_features(src: &str, test_path: &str, features: &[UnstableFeature]) {
+fn check_errors_using_features(src: &str, test_path: Option<&str>, features: &[UnstableFeature]) {
     let allow_parser_errors = false;
     let monomorphize = false;
     let options =
@@ -95,13 +95,13 @@
 }
 
 #[allow(unused)]
-pub(super) fn check_monomorphization_error(src: &str, test_path: &str) {
+pub(super) fn check_monomorphization_error(src: &str, test_path: Option<&str>) {
     check_monomorphization_error_using_features(src, test_path, &[]);
 }
 
 pub(super) fn check_monomorphization_error_using_features(
     src: &str,
-    test_path: &str,
+    test_path: Option<&str>,
     features: &[UnstableFeature],
 ) {
     let allow_parser_errors = false;
@@ -117,7 +117,7 @@
 
 fn check_errors_with_options(
     src: &str,
-    test_path: &str,
+    test_path: Option<&str>,
     allow_parser_errors: bool,
     monomorphize: bool,
     options: FrontendOptions,
@@ -284,7 +284,7 @@
 
     let chars = line.chars().collect::<Vec<_>>();
     let first_caret = chars.iter().position(|c| *c == char).unwrap();
     let last_caret = chars.iter().rposition(|c| *c == char).unwrap();
     let start = byte - last_line_length;
     let span = Span::from((start + first_caret - 1) as u32..(start + last_caret) as u32);
     let error = line.trim().trim_start_matches(char).trim().to_string();
@@ -305,7 +305,7 @@
     ($src:expr, $expect:expr, $features:expr) => {
         $crate::tests::get_program_using_features(
             $src,
-            $crate::function_path!(),
+            Some($crate::function_path!()),
             $expect,
             $features,
         )
@@ -334,7 +334,7 @@
     ($src:expr, $expect:expr, $allow_parser_errors:expr, $options:expr) => {
         $crate::tests::get_program_with_options(
             $src,
-            $crate::function_path!(),
+            Some($crate::function_path!()),
             $expect,
             $allow_parser_errors,
             $options,
@@ -354,7 +354,7 @@
 #[macro_export]
 macro_rules! check_errors {
     ($src:expr) => {
-        $crate::tests::check_errors($src, $crate::function_path!())
+        $crate::tests::check_errors($src, Some($crate::function_path!()))
     };
     ($src:expr,) => {
         $crate::check_errors!($src)
@@ -365,15 +365,15 @@
 #[macro_export]
 macro_rules! check_errors_using_features {
     ($src:expr, $features:expr) => {
-        $crate::tests::check_errors_using_features($src, $crate::function_path!(), $features)
+        $crate::tests::check_errors_using_features($src, Some($crate::function_path!()), $features)
     };
 }
 
 // NOTE: this will fail in CI when called twice within one test: test names must be unique
 #[macro_export]
 macro_rules! check_monomorphization_error {
     ($src:expr) => {
-        $crate::tests::check_monomorphization_error($src, $crate::function_path!())
+        $crate::tests::check_monomorphization_error($src, Some($crate::function_path!()))
     };
 }
 
@@ -383,7 +383,7 @@
     ($src:expr, $features:expr) => {
         $crate::tests::check_monomorphization_error_using_features(
             $src,
-            $crate::function_path!(),
+            Some($crate::function_path!()),
             $features,
         )
     };
@@ -2071,7 +2071,7 @@
         T::deserialize([0, 1])
     }
     "#;
-    check_errors(src, &format!("{}_1", function_path!()));
+    check_errors(src, Some(&format!("{}_1", function_path!())));
 
     // TODO: improve the error location for the array (should be on N)
     let src = r#"
@@ -2095,7 +2095,7 @@
         T::deserialize(fields)
     }
     "#;
-    check_errors(src, &format!("{}_2", function_path!()));
+    check_errors(src, Some(&format!("{}_2", function_path!())));
 }
 
 #[named]
@@ -3231,7 +3231,7 @@
     // wouldn't panic due to infinite recursion, but the errors asserted here
     // come from the compilation checks, which does static analysis to catch the
     // problem before it even has a chance to cause a panic.
     let srcs = vec![
         r#"
         fn main() {
            ^^^^ function `main` cannot return without recursing
@@ -3313,15 +3313,15 @@
         "#,
     ];
 
     for (index, src) in srcs.into_iter().enumerate() {
-        check_errors(src, &format!("{}_{index}", function_path!()));
+        check_errors(src, Some(&format!("{}_{index}", function_path!())));
     }
 }
 
 #[named]
 #[test]
 fn unconditional_recursion_pass() {
     let srcs = vec![
         r#"
         fn main() {
             if false { main(); }
@@ -3363,7 +3363,7 @@
         "#,
     ];
 
     for (index, src) in srcs.into_iter().enumerate() {
         assert_no_errors(src, &format!("{}_{index}", function_path!()));
     }
 }
@@ -4379,7 +4379,6 @@
     check_errors!(src);
 }
 
-#[named]
 #[test]
 fn immutable_references_with_ownership_feature() {
     let src = r#"
@@ -4392,7 +4391,7 @@
     "#;
 
     let (_, _, errors) =
-        get_program_using_features!(src, Expect::Success, &[UnstableFeature::Ownership]);
+        get_program_using_features(src, None, Expect::Success, &[UnstableFeature::Ownership]);
     assert_eq!(errors.len(), 0);
 }
 
@@ -4404,12 +4403,12 @@
             let mut array = [1, 2, 3];
             borrow(&array);
                    ^^^^^^ This requires the unstable feature 'ownership' which is not enabled
                    ~~~~~~ Pass -Zownership to nargo to enable this feature at your own risk.
         }
 
         fn borrow(_array: &[Field; 3]) {}
                           ^^^^^^^^^^^ This requires the unstable feature 'ownership' which is not enabled
                           ~~~~~~~~~~~ Pass -Zownership to nargo to enable this feature at your own risk.
     "#;
     check_errors!(src);
 }

test_programs/compile_failure/noirc_frontend_tests_immutable_references_without_ownership_feature/stderr.txt

@@ -0,0 +1,15 @@
+error: This requires the unstable feature 'ownership' which is not enabled
+  ┌─ src/main.nr:7:27
+  │
+7 │         fn borrow(_array: &[Field; 3]) {}
+  │                           ----------- Pass -Zownership to nargo to enable this feature at your own risk.
+  │
+
+error: This requires the unstable feature 'ownership' which is not enabled
+  ┌─ src/main.nr:4:20
+  │
+4 │             borrow(&array);
+  │                    ------ Pass -Zownership to nargo to enable this feature at your own risk.
+  │
+
+Aborting due to 2 previous errors

tooling/nargo_cli/tests/execute.rs

@@ -35,8 +35,7 @@
         nargo.arg("--enable-brillig-debug-assertions");
 
         // Enable enums and ownership as unstable features
         nargo.arg("-Zenums");
-        nargo.arg("-Zownership");
 
         if force_brillig.0 {
             {