fix: unify macro call type with actual type in comptime blocks

compiler/noirc_frontend/src/elaborator/function_context.rs

@@ -87,13 +87,23 @@ impl Elaborator<'_> {
 
     /// Push a type variable (its ID and type) as a required type variable: it must be
     /// bound after type-checking the current function.
+    ///
+    /// The type variable is only pushed if the elaborator is not in a comptime context.
+    /// The reason is that in a comptime context the type of a variable might change
+    /// across a loop's iterations, so a type can temporarily remain as `Type<_>` where
+    /// `_` is bound by the interpreter evaluating an expression's type being unified with
+    /// that type.
     pub(super) fn push_required_type_variable(
         &mut self,
         type_variable_id: TypeVariableId,
         typ: Type,
         kind: BindableTypeVariableKind,
         location: Location,
     ) {
+        if self.in_comptime_context() {
+            return;
+        }
+
         let var = RequiredTypeVariable { type_variable_id, typ, kind, location };
         self.get_function_context_mut().required_type_variables.push(var);
     }

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -41,7 +41,6 @@ use iter_extended::{try_vecmap, vecmap};
 use noirc_errors::Location;
 use rustc_hash::FxHashMap as HashMap;
 
-use crate::TypeVariable;
 use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, UnaryOp};
 use crate::elaborator::{ElaborateReason, Elaborator, ElaboratorOptions};
 use crate::hir::Context;
@@ -75,6 +74,7 @@ use crate::{
     },
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
 };
+use crate::{TypeVariable, UnificationError};
 
 use super::errors::{IResult, InterpreterError};
 use super::value::{Closure, Value, unwrap_rc};
@@ -1163,7 +1163,36 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                     // the macro result changes across loop iterations.
                     let expected_type = self.elaborator.interner.id_type(id);
                     let actual_type = result.get_type();
-                    self.unify_without_binding(&actual_type, &expected_type, location);
+
+                    // Undo any bindings (if any) from the last time we unified this expression's
+                    // type against the actual type
+                    if let Some(bindings) =
+                        self.elaborator.interner.macro_call_expression_bindings.remove(&id)
+                    {
+                        for (var, kind, _typ) in bindings.values() {
+                            var.unbind(var.id(), kind.clone());
+                        }
+                    }
+
+                    let mut bindings = TypeBindings::default();
+                    match actual_type.try_unify(&expected_type, &mut bindings) {
+                        Ok(()) => {
+                            // Store the bindings so we can undo them next time
+                            self.elaborator
+                                .interner
+                                .macro_call_expression_bindings
+                                .insert(id, bindings.clone());
+                            Type::apply_type_bindings(bindings);
+                        }
+                        Err(UnificationError) => {
+                            let error = TypeCheckError::TypeMismatch {
+                                expected_typ: expected_type.to_string(),
+                                expr_typ: actual_type.to_string(),
+                                expr_location: location,
+                            };
+                            self.elaborator.push_err(error);
+                        }
+                    }
                 }
                 Ok(result)
             }
@@ -1175,20 +1204,6 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
         }
     }
 
-    /// This function is used by the interpreter for some comptime code
-    /// which can change types e.g. on each iteration of a for loop.
-    fn unify_without_binding(&mut self, actual: &Type, expected: &Type, location: Location) {
-        let mut bindings = TypeBindings::default();
-        if actual.try_unify(expected, &mut bindings).is_err() {
-            let error = TypeCheckError::TypeMismatch {
-                expected_typ: expected.to_string(),
-                expr_typ: actual.to_string(),
-                expr_location: location,
-            };
-            self.elaborator.push_err(error);
-        }
-    }
-
     fn evaluate_cast(&mut self, cast: &HirCastExpression, id: ExprId) -> IResult<Value> {
         let evaluated_lhs = self.evaluate(cast.lhs)?;
         let location = self.elaborator.interner.expr_location(&id);

compiler/noirc_frontend/src/node_interner/mod.rs

@@ -304,6 +304,12 @@ pub struct NodeInterner {
     /// Tracks statements that encountered errors during elaboration.
     /// Used by the interpreter to skip evaluation of errored statements.
     pub(crate) stmts_with_errors: HashSet<StmtId>,
+
+    /// Associates type bindings that resulted from unifying the type of a macro call expression
+    /// with the expected type at the callsite.
+    /// Since a single macro call expression might end up having different types across loop
+    /// iterations, before unifying its type we undo bindings from the last time we unified it.
+    pub(crate) macro_call_expression_bindings: HashMap<ExprId, TypeBindings>,
 }
 
 /// A trait implementation is either a normal implementation that is present in the source
@@ -500,6 +506,7 @@ impl Default for NodeInterner {
             primitive_docs: HashMap::default(),
             exprs_with_errors: HashSet::default(),
             stmts_with_errors: HashSet::default(),
+            macro_call_expression_bindings: HashMap::default(),
         }
     }
 }

compiler/noirc_frontend/src/tests/metaprogramming.rs

@@ -1465,3 +1465,28 @@ fn escape_nested_unquote() {
     "#;
     assert_no_errors(src);
 }
+
+#[test]
+fn unifies_macro_call_type_with_variable_type_in_comptime_block() {
+    let src = r#"
+    comptime fn unquote(code: Quoted) -> Quoted {
+        code
+    }
+
+    struct Foo<let N: u32> {}
+
+    impl<let N: u32> Foo<N> {
+        fn len(_self: Self) -> u32 {
+            N
+        }
+    }
+
+    fn main() -> pub u32 {
+        comptime {
+            let foo: Foo<_> = unquote!(quote { Foo::<10> {} });
+            foo.len()
+        }
+    }
+    "#;
+    assert_no_errors(src);
+}