chore: easier way to test monormophization errors

compiler/noirc_frontend/src/monomorphization/tests.rs

@@ -1,5 +1,8 @@
 #![cfg(test)]
-use crate::tests::get_program;
+use crate::{
+    elaborator::UnstableFeature,
+    tests::{check_monomorphization_error_using_features, get_program},
+};
 
 use super::{ast::Program, errors::MonomorphizationError, monomorphize};
 
@@ -29,6 +32,8 @@
     let src = "
         fn main() {
             let _tree: Tree<Tree<Tree<()>>> = Tree::Branch(
+                                              ^^^^^^^^^^^^ Type `Tree<Tree<()>>` is recursive
+                                              ~~~~~~~~~~~~ All types in Noir must have a known size at compile-time
                 Tree::Branch(Tree::Leaf, Tree::Leaf),
                 Tree::Branch(Tree::Leaf, Tree::Leaf),
             );
@@ -37,10 +42,10 @@
         enum Tree<T> {
             Branch(T, T),
             Leaf,
-        }";
-
-    let error = get_monomorphized(src).unwrap_err();
-    assert!(matches!(error, MonomorphizationError::RecursiveType { .. }));
+        }
+        ";
+    let features = vec![UnstableFeature::Enums];
+    check_monomorphization_error_using_features(src, &features);
 }
 
 #[test]
@@ -63,17 +68,19 @@
     let src = "
         fn main() {
             let _tree: Opt<OptAlias<()>> = Opt::Some(OptAlias::None);
+                                           ^^^^^^^^^ Type `Opt<()>` is recursive
+                                           ~~~~~~~~~ All types in Noir must have a known size at compile-time
         }
 
         type OptAlias<T> = Opt<T>;
 
         enum Opt<T> {
             Some(T),
             None,
-        }";
-
-    let error = get_monomorphized(src).unwrap_err();
-    assert!(matches!(error, MonomorphizationError::RecursiveType { .. }));
+        }
+        ";
+    let features = vec![UnstableFeature::Enums];
+    check_monomorphization_error_using_features(src, &features);
 }
 
 #[test]
@@ -85,16 +92,18 @@
 
         enum Even {
             Zero,
+            ^^^^ Type `Odd` is recursive
+            ~~~~ All types in Noir must have a known size at compile-time
             Succ(Odd),
         }
 
         enum Odd {
             One,
             Succ(Even),
-        }";
-
-    let error = get_monomorphized(src).unwrap_err();
-    assert!(matches!(error, MonomorphizationError::RecursiveType { .. }));
+        }
+        ";
+    let features = vec![UnstableFeature::Enums];
+    check_monomorphization_error_using_features(src, &features);
 }
 
 #[test]

compiler/noirc_frontend/src/tests.rs

@@ -158,17 +158,45 @@
 /// will produce errors at those locations and with/ those messages.
 fn check_errors(src: &str) {
     let allow_parser_errors = false;
-    check_errors_with_options(src, allow_parser_errors, FrontendOptions::test_default());
+    let monomorphize = false;
+    check_errors_with_options(
+        src,
+        allow_parser_errors,
+        monomorphize,
+        FrontendOptions::test_default(),
+    );
 }
 
 fn check_errors_using_features(src: &str, features: &[UnstableFeature]) {
     let allow_parser_errors = false;
-    let mut options = FrontendOptions::test_default();
-    options.enabled_unstable_features = features;
-    check_errors_with_options(src, allow_parser_errors, options);
+    let monomorphize = false;
+    let options =
+        FrontendOptions { enabled_unstable_features: features, ..FrontendOptions::test_default() };
+    check_errors_with_options(src, allow_parser_errors, monomorphize, options);
+}
+
+#[allow(unused)]
+pub(super) fn check_monomorphization_error(src: &str) {
+    check_monomorphization_error_using_features(src, &[]);
+}
+
+pub(super) fn check_monomorphization_error_using_features(src: &str, features: &[UnstableFeature]) {
+    let allow_parser_errors = false;
+    let monomorphize = true;
+    check_errors_with_options(
+        src,
+        allow_parser_errors,
+        monomorphize,
+        FrontendOptions { enabled_unstable_features: features, ..FrontendOptions::test_default() },
+    );
 }
 
-fn check_errors_with_options(src: &str, allow_parser_errors: bool, options: FrontendOptions) {
+fn check_errors_with_options(
+    src: &str,
+    allow_parser_errors: bool,
+    monomorphize: bool,
+    options: FrontendOptions,
+) {
     let lines = src.lines().collect::<Vec<_>>();
 
     // Here we'll hold just the lines that are code
@@ -213,12 +241,31 @@
         secondary_spans_with_errors.into_iter().collect();
 
     let src = code_lines.join("\n");
-    let (_, _, errors) = get_program_with_options(&src, allow_parser_errors, options);
+    let (_, mut context, errors) = get_program_with_options(&src, allow_parser_errors, options);
+    let mut errors = errors.iter().map(CustomDiagnostic::from).collect::<Vec<_>>();
+
+    if monomorphize {
+        if !errors.is_empty() {
+            panic!("Expected no errors before monomorphization, got: {:?}", errors);
+        }
+
+        let main = context.get_main_function(context.root_crate_id()).unwrap_or_else(|| {
+            panic!("get_monomorphized: test program contains no 'main' function")
+        });
+
+        let result = crate::monomorphization::monomorphize(main, &mut context.def_interner, false);
+        match result {
+            Ok(_) => panic!("Expected a monomorphization error but got none"),
+            Err(error) => {
+                errors.push(error.into());
+            }
+        }
+    }
+
     if errors.is_empty() && !primary_spans_with_errors.is_empty() {
         panic!("Expected some errors but got none");
     }
 
-    let errors = errors.iter().map(CustomDiagnostic::from).collect::<Vec<_>>();
     for error in &errors {
         let secondary = error
             .secondaries
@@ -290,7 +337,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();
@@ -2971,7 +3018,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
@@ -3053,14 +3100,14 @@
         "#,
     ];
 
     for src in srcs {
         check_errors(src);
     }
 }
 
 #[test]
 fn unconditional_recursion_pass() {
     let srcs = vec![
         r#"
         fn main() {
             if false { main(); }
@@ -3102,7 +3149,7 @@
         "#,
     ];
 
     for src in srcs {
         assert_no_errors(src);
     }
 }
@@ -4088,12 +4135,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);
 }