Track elaborate reason when calling comptime builtin

asterite · asterite · commit 49a3fab89b7d · 2025-03-06T13:27:19.000-03:00
diff --git a/compiler/noirc_frontend/src/elaborator/comptime.rs b/compiler/noirc_frontend/src/elaborator/comptime.rs
@@ -342,14 +342,11 @@ impl<'context> Elaborator<'context> {
         generated_items: &mut CollectedItems,
         location: Location,
     ) {
-        let previous_errors =
-            self.push_elaborate_reason_and_take_errors(ElaborateReason::RunningAttribute, location);
-
-        for item in items {
-            self.add_item(item, generated_items, location);
-        }
-
-        self.pop_elaborate_reason(previous_errors);
+        self.with_elaborate_reason(ElaborateReason::RunningAttribute(location), |elaborator| {
+            for item in items {
+                elaborator.add_item(item, generated_items, location);
+            }
+        })
     }
 
     pub(crate) fn add_item(
@@ -558,14 +555,10 @@ impl<'context> Elaborator<'context> {
             });
 
             if !generated_items.is_empty() {
-                let previous_errors = self.push_elaborate_reason_and_take_errors(
-                    ElaborateReason::RunningAttribute,
-                    location,
-                );
-
-                self.elaborate_items(generated_items);
-
-                self.pop_elaborate_reason(previous_errors);
+                let reason = ElaborateReason::RunningAttribute(location);
+                self.with_elaborate_reason(reason, |elaborator| {
+                    elaborator.elaborate_items(generated_items)
+                });
             }
         }
     }
@@ -652,33 +645,31 @@ impl<'context> Elaborator<'context> {
             }
     }
 
-    /// Pushes an ElaborateReason but also `std::mem::take`s the current errors and returns them.
-    pub(crate) fn push_elaborate_reason_and_take_errors(
-        &mut self,
-        reason: ElaborateReason,
-        location: Location,
-    ) -> Vec<CompilationError> {
-        self.elaborate_reasons.push_back((reason, location));
-        std::mem::take(&mut self.errors)
-    }
+    pub(crate) fn with_elaborate_reason<F, T>(&mut self, reason: ElaborateReason, f: F) -> T
+    where
+        F: FnOnce(&mut Elaborator) -> T,
+    {
+        self.elaborate_reasons.push_back(reason);
+        let previous_errors = std::mem::take(&mut self.errors);
+
+        let value = f(self);
 
-    /// Pops en ElaborateREason. Receives the errors that were returned by `push_elaborate_reason`
-    /// so they are restored, while also wrapping errors in the current Elaborator in a ComptimeError.
-    pub(crate) fn pop_elaborate_reason(&mut self, previous_errors: Vec<CompilationError>) {
         let new_errors = std::mem::take(&mut self.errors);
         let new_errors = self.wrap_errors_in_macro_error(new_errors);
         self.errors = previous_errors;
         self.push_errors(new_errors);
         self.elaborate_reasons.pop_back();
+
+        value
     }
 
     fn wrap_errors_in_macro_error(&self, errors: Vec<CompilationError>) -> Vec<CompilationError> {
         vecmap(errors, |error| self.wrap_error_in_macro_error(error))
     }
 
     fn wrap_error_in_macro_error(&self, mut error: CompilationError) -> CompilationError {
-        for (reason, location) in self.elaborate_reasons.iter().rev() {
-            error = CompilationError::ComptimeError(reason.to_macro_error(error, *location));
+        for reason in self.elaborate_reasons.iter().rev() {
+            error = CompilationError::ComptimeError(reason.to_macro_error(error));
         }
         error
     }
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -199,25 +199,26 @@ pub struct Elaborator<'context> {
     /// Sometimes items are elaborated because a function attribute ran and generated items.
     /// The Elaborator keeps track of these reasons so that when an error is produced it will
     /// be wrapped in another error that will include this reason.
-    pub(crate) elaborate_reasons: im::Vector<(ElaborateReason, Location)>,
+    pub(crate) elaborate_reasons: im::Vector<ElaborateReason>,
 }
 
 #[derive(Copy, Clone)]
 pub enum ElaborateReason {
     /// A function attribute generated an item that's being elaborated.
-    RunningAttribute,
-    /// Evaluating `Module::add_item`
-    AddingItemToModule,
+    RunningAttribute(Location),
+    /// Evaluating a comptime call like `Module::add_item`
+    EvaluatingComptimeCall(&'static str, Location),
 }
 
 impl ElaborateReason {
-    fn to_macro_error(self, error: CompilationError, location: Location) -> ComptimeError {
+    fn to_macro_error(self, error: CompilationError) -> ComptimeError {
         match self {
-            ElaborateReason::RunningAttribute => {
+            ElaborateReason::RunningAttribute(location) => {
                 ComptimeError::ErrorRunningAttribute { error: Box::new(error), location }
             }
-            ElaborateReason::AddingItemToModule => {
-                ComptimeError::ErrorAddingItemToModule { error: Box::new(error), location }
+            ElaborateReason::EvaluatingComptimeCall(method_name, location) => {
+                let error = Box::new(error);
+                ComptimeError::ErrorEvaluatingComptimeCall { method_name, error, location }
             }
         }
     }
@@ -251,7 +252,7 @@ impl<'context> Elaborator<'context> {
         crate_id: CrateId,
         interpreter_call_stack: im::Vector<Location>,
         options: ElaboratorOptions<'context>,
-        elaborate_reasons: im::Vector<(ElaborateReason, Location)>,
+        elaborate_reasons: im::Vector<ElaborateReason>,
     ) -> Self {
         Self {
             scopes: ScopeForest::default(),
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -703,15 +703,22 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
 /// comptime call or macro "something" that eventually led to that error.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ComptimeError {
-    ErrorRunningAttribute { error: Box<CompilationError>, location: Location },
-    ErrorAddingItemToModule { error: Box<CompilationError>, location: Location },
+    ErrorRunningAttribute {
+        error: Box<CompilationError>,
+        location: Location,
+    },
+    ErrorEvaluatingComptimeCall {
+        method_name: &'static str,
+        error: Box<CompilationError>,
+        location: Location,
+    },
 }
 
 impl ComptimeError {
     pub fn location(&self) -> Location {
         match self {
             ComptimeError::ErrorRunningAttribute { location, .. }
-            | ComptimeError::ErrorAddingItemToModule { location, .. } => *location,
+            | ComptimeError::ErrorEvaluatingComptimeCall { location, .. } => *location,
         }
     }
 }
@@ -724,9 +731,9 @@ impl<'a> From<&'a ComptimeError> for CustomDiagnostic {
                 diagnostic.add_secondary("While running this function attribute".into(), *location);
                 diagnostic
             }
-            ComptimeError::ErrorAddingItemToModule { error, location } => {
+            ComptimeError::ErrorEvaluatingComptimeCall { method_name, error, location } => {
                 let mut diagnostic = CustomDiagnostic::from(&**error);
-                diagnostic.add_secondary("While interpreting `Module::add_item`".into(), *location);
+                diagnostic.add_secondary(format!("While evaluating `{method_name}`"), *location);
                 diagnostic
             }
         }
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs
@@ -833,9 +833,12 @@ fn quoted_as_module(
         parse(interpreter.elaborator, argument, Parser::parse_path_no_turbofish_or_error, "a path")
             .ok();
     let option_value = path.and_then(|path| {
-        let module = interpreter
-            .elaborate_in_function(interpreter.current_function, |elaborator| {
-                elaborator.resolve_module_by_path(path)
+        let module =
+            interpreter.elaborate_in_function(interpreter.current_function, |elaborator| {
+                let reason = ElaborateReason::EvaluatingComptimeCall("Quoted::as_module", location);
+                elaborator.with_elaborate_reason(reason, |elaborator| {
+                    elaborator.resolve_module_by_path(path)
+                })
             });
         module.map(Value::ModuleDefinition)
     });
@@ -858,7 +861,11 @@ fn quoted_as_trait_constraint(
     )?;
     let bound = interpreter
         .elaborate_in_function(interpreter.current_function, |elaborator| {
-            elaborator.resolve_trait_bound(&trait_bound)
+            let reason =
+                ElaborateReason::EvaluatingComptimeCall("Quoted::as_trait_constraint", location);
+            elaborator.with_elaborate_reason(reason, |elaborator| {
+                elaborator.resolve_trait_bound(&trait_bound)
+            })
         })
         .ok_or(InterpreterError::FailedToResolveTraitBound { trait_bound, location })?;
 
@@ -873,8 +880,10 @@ fn quoted_as_type(
 ) -> IResult<Value> {
     let argument = check_one_argument(arguments, location)?;
     let typ = parse(interpreter.elaborator, argument, Parser::parse_type_or_error, "a type")?;
-    let typ = interpreter
-        .elaborate_in_function(interpreter.current_function, |elab| elab.resolve_type(typ));
+    let typ = interpreter.elaborate_in_function(interpreter.current_function, |elaborator| {
+        let reason = ElaborateReason::EvaluatingComptimeCall("Quoted::as_type", location);
+        elaborator.with_elaborate_reason(reason, |elaborator| elaborator.resolve_type(typ))
+    });
     Ok(Value::Type(typ))
 }
 
@@ -2292,32 +2301,37 @@ fn expr_resolve(
         interpreter.current_function
     };
 
-    interpreter.elaborate_in_function(function_to_resolve_in, |elaborator| match expr_value {
-        ExprValue::Expression(expression_kind) => {
-            let expr = Expression { kind: expression_kind, location: self_argument_location };
-            let (expr_id, _) = elaborator.elaborate_expression(expr);
-            Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
-        }
-        ExprValue::Statement(statement_kind) => {
-            let statement = Statement { kind: statement_kind, location: self_argument_location };
-            let (stmt_id, _) = elaborator.elaborate_statement(statement);
-            Ok(Value::TypedExpr(TypedExpr::StmtId(stmt_id)))
-        }
-        ExprValue::LValue(lvalue) => {
-            let expr = lvalue.as_expression();
-            let (expr_id, _) = elaborator.elaborate_expression(expr);
-            Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
-        }
-        ExprValue::Pattern(pattern) => {
-            if let Some(expression) = pattern.try_as_expression(elaborator.interner) {
-                let (expr_id, _) = elaborator.elaborate_expression(expression);
+    interpreter.elaborate_in_function(function_to_resolve_in, |elaborator| {
+        let reason = ElaborateReason::EvaluatingComptimeCall("Expr::resolve", location);
+        elaborator.with_elaborate_reason(reason, |elaborator| match expr_value {
+            ExprValue::Expression(expression_kind) => {
+                let expr = Expression { kind: expression_kind, location: self_argument_location };
+                let (expr_id, _) = elaborator.elaborate_expression(expr);
                 Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
-            } else {
-                let expression = Value::pattern(pattern).display(elaborator.interner).to_string();
-                let location = self_argument_location;
-                Err(InterpreterError::CannotResolveExpression { location, expression })
             }
-        }
+            ExprValue::Statement(statement_kind) => {
+                let statement =
+                    Statement { kind: statement_kind, location: self_argument_location };
+                let (stmt_id, _) = elaborator.elaborate_statement(statement);
+                Ok(Value::TypedExpr(TypedExpr::StmtId(stmt_id)))
+            }
+            ExprValue::LValue(lvalue) => {
+                let expr = lvalue.as_expression();
+                let (expr_id, _) = elaborator.elaborate_expression(expr);
+                Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
+            }
+            ExprValue::Pattern(pattern) => {
+                if let Some(expression) = pattern.try_as_expression(elaborator.interner) {
+                    let (expr_id, _) = elaborator.elaborate_expression(expression);
+                    Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
+                } else {
+                    let expression =
+                        Value::pattern(pattern).display(elaborator.interner).to_string();
+                    let location = self_argument_location;
+                    Err(InterpreterError::CannotResolveExpression { location, expression })
+                }
+            }
+        })
     })
 }
 
@@ -2427,7 +2441,11 @@ fn function_def_as_typed_expr(
     let expr_id = interpreter.elaborator.interner.push_expr(hir_expr);
     interpreter.elaborator.interner.push_expr_location(expr_id, location);
     let typ = interpreter.elaborate_in_function(interpreter.current_function, |elaborator| {
-        elaborator.type_check_variable(hir_ident, expr_id, generics)
+        let reason =
+            ElaborateReason::EvaluatingComptimeCall("FunctionDefinition::as_typed_expr", location);
+        elaborator.with_elaborate_reason(reason, |elaborator| {
+            elaborator.type_check_variable(hir_ident, expr_id, generics)
+        })
     });
     interpreter.elaborator.interner.push_expr_type(expr_id, typ);
     Ok(Value::TypedExpr(TypedExpr::ExprId(expr_id)))
@@ -2635,13 +2653,19 @@ fn function_def_set_parameters(
         )?;
 
         let hir_pattern = interpreter.elaborate_in_function(Some(func_id), |elaborator| {
-            elaborator.elaborate_pattern_and_store_ids(
-                parameter_pattern,
-                parameter_type.clone(),
-                DefinitionKind::Local(None),
-                &mut parameter_idents,
-                true, // warn_if_unused
-            )
+            let reason = ElaborateReason::EvaluatingComptimeCall(
+                "FunctionDefinition::set_parameters",
+                location,
+            );
+            elaborator.with_elaborate_reason(reason, |elaborator| {
+                elaborator.elaborate_pattern_and_store_ids(
+                    parameter_pattern,
+                    parameter_type.clone(),
+                    DefinitionKind::Local(None),
+                    &mut parameter_idents,
+                    true, // warn_if_unused
+                )
+            })
         });
 
         parameters.push((hir_pattern, parameter_type.clone(), Visibility::Private));
@@ -2750,20 +2774,18 @@ fn module_add_item(
     let top_level_statements = parse(interpreter.elaborator, item, parser, "a top-level item")?;
 
     interpreter.elaborate_in_module(module_id, |elaborator| {
-        let previous_errors = elaborator
-            .push_elaborate_reason_and_take_errors(ElaborateReason::AddingItemToModule, location);
-
-        let mut generated_items = CollectedItems::default();
+        let reason = ElaborateReason::EvaluatingComptimeCall("Module::add_item", location);
+        elaborator.with_elaborate_reason(reason, |elaborator| {
+            let mut generated_items = CollectedItems::default();
 
-        for top_level_statement in top_level_statements {
-            elaborator.add_item(top_level_statement, &mut generated_items, location);
-        }
-
-        if !generated_items.is_empty() {
-            elaborator.elaborate_items(generated_items);
-        }
+            for top_level_statement in top_level_statements {
+                elaborator.add_item(top_level_statement, &mut generated_items, location);
+            }
 
-        elaborator.pop_elaborate_reason(previous_errors);
+            if !generated_items.is_empty() {
+                elaborator.elaborate_items(generated_items);
+            }
+        });
     });
 
     Ok(Value::Unit)

Original file line number	Diff line number	Diff line change
`@@ -703,15 +703,22 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {`
`703`	`703`	`/// comptime call or macro "something" that eventually led to that error.`
`704`	`704`	`#[derive(Debug, Clone, PartialEq, Eq)]`
`705`	`705`	`pub enum ComptimeError {`
`706`		`- ErrorRunningAttribute { error: Box<CompilationError>, location: Location },`
`707`		`- ErrorAddingItemToModule { error: Box<CompilationError>, location: Location },`
	`706`	`+ ErrorRunningAttribute {`
	`707`	`+ error: Box<CompilationError>,`
	`708`	`+ location: Location,`
	`709`	`+ },`
	`710`	`+ ErrorEvaluatingComptimeCall {`
	`711`	`+ method_name: &'static str,`
	`712`	`+ error: Box<CompilationError>,`
	`713`	`+ location: Location,`
	`714`	`+ },`
`708`	`715`	`}`
`709`	`716`
`710`	`717`	`impl ComptimeError {`
`711`	`718`	`pub fn location(&self) -> Location {`
`712`	`719`	`match self {`
`713`	`720`	`ComptimeError::ErrorRunningAttribute { location, .. }`
`714`		`- \| ComptimeError::ErrorAddingItemToModule { location, .. } => *location,`
	`721`	`+ \| ComptimeError::ErrorEvaluatingComptimeCall { location, .. } => *location,`
`715`	`722`	`}`
`716`	`723`	`}`
`717`	`724`	`}`
`@@ -724,9 +731,9 @@ impl<'a> From<&'a ComptimeError> for CustomDiagnostic {`
`724`	`731`	`diagnostic.add_secondary("While running this function attribute".into(), *location);`
`725`	`732`	`diagnostic`
`726`	`733`	`}`
`727`		`- ComptimeError::ErrorAddingItemToModule { error, location } => {`
	`734`	`+ ComptimeError::ErrorEvaluatingComptimeCall { method_name, error, location } => {`
`728`	`735`	`let mut diagnostic = CustomDiagnostic::from(&**error);`
`729`		- diagnostic.add_secondary("While interpreting `Module::add_item`".into(), *location);
	`736`	+ diagnostic.add_secondary(format!("While evaluating `{method_name}`"), *location);
`730`	`737`	`diagnostic`
`731`	`738`	`}`
`732`	`739`	`}`