fix: when macro parse error happens, discard warnings; also preserve unquoted token locations

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

@@ -266,7 +266,7 @@
             }
         } else {
             let name = self.elaborator.interner.function_name(&function);
             unreachable!("Non-builtin, lowlevel or oracle builtin fn '{name}'")
         }
     }
 
@@ -554,7 +554,7 @@
             HirExpression::Match(match_) => todo!("Evaluate match in comptime code"),
             HirExpression::Tuple(tuple) => self.evaluate_tuple(tuple),
             HirExpression::Lambda(lambda) => self.evaluate_lambda(lambda, id),
-            HirExpression::Quote(tokens) => self.evaluate_quote(tokens, id),
+            HirExpression::Quote(tokens) => self.evaluate_quote(tokens),
             HirExpression::Unsafe(block) => self.evaluate_block(block),
             HirExpression::EnumConstructor(constructor) => {
                 self.evaluate_enum_constructor(constructor, id)
@@ -1097,9 +1097,8 @@
         Ok(Value::Closure(Box::new(closure)))
     }
 
-    fn evaluate_quote(&mut self, mut tokens: Tokens, expr_id: ExprId) -> IResult<Value> {
-        let location = self.elaborator.interner.expr_location(&expr_id);
-        let tokens = self.substitute_unquoted_values_into_tokens(tokens, location)?;
+    fn evaluate_quote(&mut self, mut tokens: Tokens) -> IResult<Value> {
+        let tokens = self.substitute_unquoted_values_into_tokens(tokens)?;
         Ok(Value::Quoted(Rc::new(tokens)))
     }
 

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

@@ -529,8 +529,9 @@ pub(super) fn parse_tokens<'a, T, F>(
 where
     F: FnOnce(&mut Parser<'a>) -> T,
 {
-    Parser::for_tokens(quoted).parse_result(parsing_function).map_err(|mut errors| {
-        let error = Box::new(errors.swap_remove(0));
+    Parser::for_tokens(quoted).parse_result(parsing_function).map_err(|errors| {
+        let error = errors.into_iter().find(|error| !error.is_warning()).unwrap();
+        let error = Box::new(error);
         let tokens = tokens_to_string(&tokens, interner);
         InterpreterError::FailedToParseMacro { error, tokens, rule, location }
     })

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

@@ -1,5 +1,3 @@
-use noirc_errors::Location;
-
 use crate::{
     hir::comptime::errors::IResult,
     token::{LocatedToken, Token, Tokens},
@@ -14,15 +12,14 @@ impl Interpreter<'_, '_> {
     pub(super) fn substitute_unquoted_values_into_tokens(
         &mut self,
         tokens: Tokens,
-        location: Location,
     ) -> IResult<Vec<LocatedToken>> {
         let mut new_tokens = Vec::with_capacity(tokens.0.len());
 
         for token in tokens.0 {
             match token.token() {
                 Token::UnquoteMarker(id) => {
                     let value = self.evaluate(*id)?;
-                    let tokens = value.into_tokens(self.elaborator.interner, location)?;
+                    let tokens = value.into_tokens(self.elaborator.interner, token.location())?;
                     new_tokens.extend(tokens);
                 }
                 _ => new_tokens.push(token),

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

@@ -111,8 +111,8 @@
         Value::Expr(Box::new(ExprValue::Statement(statement)))
     }
 
     pub(crate) fn lvalue(lvaue: LValue) -> Self {
         Value::Expr(Box::new(ExprValue::LValue(lvaue)))
     }
 
     pub(crate) fn pattern(pattern: Pattern) -> Self {
@@ -286,8 +286,9 @@
 
                         Ok(expr)
                     }
-                    Err(mut errors) => {
-                        let error = Box::new(errors.swap_remove(0));
+                    Err(errors) => {
+                        let error = errors.into_iter().find(|error| !error.is_warning()).unwrap();
+                        let error = Box::new(error);
                         let rule = "an expression";
                         let tokens = tokens_to_string(&tokens, elaborator.interner);
                         Err(InterpreterError::FailedToParseMacro { error, tokens, rule, location })
@@ -670,8 +671,9 @@
             }
             Ok(expr)
         }
-        Err(mut errors) => {
-            let error = Box::new(errors.swap_remove(0));
+        Err(errors) => {
+            let error = errors.into_iter().find(|error| !error.is_warning()).unwrap();
+            let error = Box::new(error);
             let tokens = tokens_to_string(&tokens, elaborator.interner);
             Err(InterpreterError::FailedToParseMacro { error, tokens, rule, location })
         }

test_programs/compile_failure/comptime_error_on_macro_expansion/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "comptime_error_on_macro_expansion_1"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]

test_programs/compile_failure/comptime_error_on_macro_expansion/src/main.nr

@@ -0,0 +1,42 @@
+mod other;
+use other::expr;
+
+#[foo]
+comptime fn foo(_: FunctionDefinition) -> Quoted {
+    quote {
+        pub fn generated_by_foo() {
+            1 + "a";
+        }
+    }
+}
+
+#[bar]
+comptime fn bar(_: FunctionDefinition) -> Quoted {
+    let expr = expr();
+    quote {
+        pub fn generated_by_bar() {
+            $expr;
+        }
+    }
+}
+
+#[derive_bn254_impl]
+pub struct BN254 {}
+
+comptime fn derive_bn254_impl(s: TypeDefinition) -> Quoted {
+    let typ = s.as_type();
+    quote {
+        impl BN254 {
+            fn one() {}
+
+            fn mul<let NScalarSlices: u32>(self, scalar: ScalarField<NScalarSlices>) -> Self {
+                unconstrained_function();
+                crate::mul_with_hint($typ, scalar, transcript)
+            }
+        }
+    }
+}
+
+pub unconstrained fn unconstrained_function() {}
+
+fn main() {}

test_programs/compile_failure/comptime_error_on_macro_expansion/src/other.nr

@@ -0,0 +1,3 @@
+pub comptime fn expr() -> Quoted {
+    quote { 1 + "a" }
+}