fix: Monomorphize function values as pairs of (constrained, unconstrained)

EXTERNAL_NOIR_LIBRARIES.yml

@@ -89,7 +89,7 @@ libraries:
     repo: AztecProtocol/aztec-packages
     ref: *AZ_COMMIT
     path: noir-projects/noir-protocol-circuits/crates/parity-lib
-    timeout: 4
+    timeout: 7
     critical: false
   protocol_circuits_private_kernel_lib:
     repo: AztecProtocol/aztec-packages

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -2652,7 +2652,7 @@ pub mod test_utils {
         };
 
         let mut monomorphizer =
-            Monomorphizer::new(elaborator.interner, DebugTypeTracker::default());
+            Monomorphizer::new(elaborator.interner, DebugTypeTracker::default(), false);
         Ok(monomorphizer.expr(expr_id).expect("monomorphization error while converting interpreter execution result, should not be possible"))
     }
 }

compiler/noirc_frontend/src/monomorphization/printer.rs

@@ -22,7 +22,7 @@ pub struct FunctionPrintOptions {
 }
 
 /// Some calls can be printed with the intention of parsing the code.
-#[derive(PartialEq)]
+#[derive(Debug, PartialEq)]
 enum SpecialCall {
     Print,
     Object(String),
@@ -499,29 +499,49 @@ impl AstPrinter {
         write!(f, ")")
     }
 
+    fn get_called_function(expr: &Expression) -> Option<(bool, &Definition, &String)> {
+        let is_unconstrained = |typ: &Type| match typ {
+            Type::Function(_, _, _, unconstrained) => *unconstrained,
+            Type::Tuple(elements) => match elements.first() {
+                Some(Type::Function(_, _, _, unconstrained)) => *unconstrained,
+                _ => false,
+            },
+            _ => false,
+        };
+
+        match expr {
+            Expression::Ident(Ident { typ, definition, name, .. }) => {
+                Some((is_unconstrained(typ), definition, name))
+            }
+            Expression::Tuple(elements) => match elements.first() {
+                Some(Expression::Ident(Ident { typ, definition, name, .. })) => {
+                    Some((is_unconstrained(typ), definition, name))
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
     fn print_call(
         &mut self,
         call: &super::ast::Call,
         f: &mut Formatter,
     ) -> Result<(), std::fmt::Error> {
-        let (print_unsafe, special) = match call.func.as_ref() {
-            Expression::Ident(Ident {
-                typ: Type::Function(_, _, _, unconstrained),
-                definition,
-                name,
-                ..
-            }) => {
-                let is_unsafe = *unconstrained && !self.in_unconstrained;
-                let special = match definition {
-                    Definition::Oracle(s) if s == "print" => Some(SpecialCall::Print),
-                    Definition::Builtin(s) if s.starts_with("array") || s.starts_with("slice") => {
-                        Some(SpecialCall::Object(name.clone()))
-                    }
-                    _ => None,
-                };
-                (is_unsafe, special)
-            }
-            _ => (false, None),
+        let (print_unsafe, special) = if let Some((unconstrained, definition, name)) =
+            Self::get_called_function(&call.func)
+        {
+            let is_unsafe = unconstrained && !self.in_unconstrained;
+            let special = match definition {
+                Definition::Oracle(s) if s == "print" => Some(SpecialCall::Print),
+                Definition::Builtin(s) if s.starts_with("array") || s.starts_with("slice") => {
+                    Some(SpecialCall::Object(name.clone()))
+                }
+                _ => None,
+            };
+            (is_unsafe, special)
+        } else {
+            (false, None)
         };
 
         if let Some(special) = special {

compiler/noirc_frontend/src/monomorphization/tests.rs

@@ -120,20 +120,29 @@ fn simple_closure_with_no_captured_variables() {
     insta::assert_snapshot!(program, @r"
     fn main$f0(y$l0: call_data(0) Field) -> pub Field {
         let x$l1 = 1;
-        let closure$l4 = {
+        let closure$l6 = ({
             let closure_variable$l3 = {
                 let env$l2 = (x$l1);
                 (env$l2, lambda$f1)
             };
             closure_variable$l3
-        };
+        }, {
+            let closure_variable$l5 = {
+                let env$l4 = (x$l1);
+                (env$l4, lambda$f2)
+            };
+            closure_variable$l5
+        });
         {
-            let tmp$l5 = closure$l4;
-            tmp$l5.1(tmp$l5.0)
+            let tmp$l7 = closure$l6.0;
+            tmp$l7.1(tmp$l7.0)
         }
     }
     fn lambda$f1(mut env$l2: (Field,)) -> Field {
         env$l2.0
     }
+    unconstrained fn lambda$f2(mut env$l4: (Field,)) -> Field {
+        env$l4.0
+    }
     ");
 }

cspell.json

@@ -72,6 +72,7 @@
         "comptime",
         "concat",
         "cond",
+        "constrainedness",
         "cpus",
         "cranelift",
         "critesjosh",

test_programs/execution_success/dual_constrained_lambdas/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "dual_constrained_lambdas"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/dual_constrained_lambdas/src/main.nr

@@ -0,0 +1,32 @@
+fn main() {
+    foo(|| std::runtime::is_unconstrained());
+}
+
+// #7289 originates from a lambda being used in both acir & brillig
+fn foo(is_brillig: fn() -> bool) {
+    // If this is true the `--force-brillig` flag was passed
+    let force_brillig = std::runtime::is_unconstrained();
+
+    assert(!acir_function(is_brillig) | force_brillig);
+
+    // safety:
+    unsafe {
+        assert(brillig_function(is_brillig));
+        assert(brillig_function2(is_brillig));
+    };
+}
+
+fn acir_function(f: fn() -> bool) -> bool {
+    f()
+}
+
+unconstrained fn brillig_function(f: fn() -> bool) -> bool {
+    f()
+}
+
+// acir_function should become unconstrained when called in
+// an unconstrained context - and this should apply to the lambda
+// it takes as an argument as well.
+unconstrained fn brillig_function2(f: fn() -> bool) -> bool {
+    acir_function(f)
+}

tooling/ast_fuzzer/tests/mono.rs

@@ -43,6 +43,11 @@ fn arb_ast_roundtrip() {
             // and also rationalizes removes branches that can never be matched,
             // (like repeated patterns, superfluous defaults). For now ignore these.
             avoid_match: true,
+            // Since #9484 the monomorphizer represents function values as a pair of
+            // `(constrained, unconstrained)` where each element is a different runtime of the same
+            // function. The fuzzer has not yet been updated to mimic this so first-class functions
+            // are avoided for now.
+            avoid_lambdas: true,
             // The formatting of `unsafe { ` becomes `{ unsafe {` with extra line breaks.
             // Let's stick to just Brillig so there is no need for `unsafe` at all.
             force_brillig: true,

tooling/nargo_cli/build.rs

@@ -740,7 +740,8 @@ fn generate_interpret_execution_success_tests(test_file: &mut File, test_data_di
 }
 
 /// Run integration tests with the `--minimal-ssa` option and check that the return
-/// value matches the expectations.
+/// value matches the expectations. This also enables `--force-brillig` since `--minimal-ssa`
+/// is only valid when all functions are unconstrained.
 fn generate_minimal_execution_success_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_type = "execution_success";
     let test_cases = read_test_cases(test_data_dir, test_type);