fix: fix an ICE happening when we call a closure result from if/else

crates/nargo_cli/tests/test_data/higher_order_functions/src/main.nr

@@ -36,6 +36,8 @@ fn main() -> pub Field {
     x += 1;
     assert(closure_capturing_mutable(1) == 5);
 
+    regression_2154();
+
     let ret = twice(add1, 3);
 
     test_array_functions();
@@ -85,3 +87,21 @@ fn add1(x: Field) -> Field {
 fn twice(f: fn(Field) -> Field, x: Field) -> Field {
     f(f(x))
 }
+
+// Fixing an ICE, where rewriting the closures
+// during monomorphization didn't correspond
+// to an internal `if` type
+// found by @jfecher:
+// https://github.com/noir-lang/noir/pull/1959#issuecomment-1658992989
+// issue https://github.com/noir-lang/noir/issues/2154
+fn regression_2154() {
+    let x: u32 = 32;
+
+    let closure_if_else = if x > 2 {
+        || x
+    } else {
+        || x + 2342
+    };
+
+    assert(closure_if_else() == 32);
+}

crates/noirc_frontend/src/monomorphization/mod.rs

@@ -689,8 +689,19 @@
             HirType::Function(args, ret, env) => {
                 let args = vecmap(args, Self::convert_type);
                 let ret = Box::new(Self::convert_type(ret));
-                let env = Box::new(Self::convert_type(env));
-                ast::Type::Function(args, ret, env)
+                let env = Self::convert_type(env);
+                match &env {
+                    ast::Type::Unit => ast::Type::Function(args, ret, Box::new(env)),
+                    ast::Type::Tuple(_elements) => ast::Type::Tuple(vec![
+                        env.clone(),
+                        ast::Type::Function(args, ret, Box::new(env)),
+                    ]),
+                    _ => {
+                        unreachable!(
+                            "internal Type::Function env should be either a Unit or a Tuple, not {env}"
+                        )
+                    }
+                }
             }
 
             HirType::MutableReference(element) => {
@@ -1045,7 +1056,7 @@
         expr: node_interner::ExprId,
     ) -> (ast::Expression, ast::Expression) {
         // returns (<closure setup>, <closure variable>)
         //   which can be used directly in callsites or transformed
         //   directly to a single `Expression`
         // for other cases by `lambda` which is called by `expr`
         //