Make comptime elaboration take an optional reason

Author: asterite

compiler/noirc_frontend/src/elaborator/comptime.rs

@@ -49,9 +49,10 @@ impl<'context> Elaborator<'context> {
     pub fn elaborate_item_from_comptime_in_function<'a, T>(
         &'a mut self,
         current_function: Option<FuncId>,
+        reason: Option<ElaborateReason>,
         f: impl FnOnce(&mut Elaborator<'a>) -> T,
     ) -> T {
-        self.elaborate_item_from_comptime(f, |elaborator| {
+        self.elaborate_item_from_comptime(reason, f, |elaborator| {
             if let Some(function) = current_function {
                 let meta = elaborator.interner.function_meta(&function);
                 elaborator.current_item = Some(DependencyId::Function(function));
@@ -65,9 +66,10 @@ impl<'context> Elaborator<'context> {
     pub fn elaborate_item_from_comptime_in_module<'a, T>(
         &'a mut self,
         module: ModuleId,
+        reason: Option<ElaborateReason>,
         f: impl FnOnce(&mut Elaborator<'a>) -> T,
     ) -> T {
-        self.elaborate_item_from_comptime(f, |elaborator| {
+        self.elaborate_item_from_comptime(reason, f, |elaborator| {
             elaborator.current_item = None;
             elaborator.crate_id = module.krate;
             elaborator.local_module = module.local_id;
@@ -76,6 +78,7 @@ impl<'context> Elaborator<'context> {
 
     fn elaborate_item_from_comptime<'a, T>(
         &'a mut self,
+        reason: Option<ElaborateReason>,
         f: impl FnOnce(&mut Elaborator<'a>) -> T,
         setup: impl FnOnce(&mut Elaborator<'a>),
     ) -> T {
@@ -104,7 +107,14 @@ impl<'context> Elaborator<'context> {
         let result = f(&mut elaborator);
         elaborator.check_and_pop_function_context();
 
-        self.errors.append(&mut elaborator.errors);
+        let mut errors = std::mem::take(&mut elaborator.errors);
+        if let Some(reason) = reason {
+            errors = vecmap(errors, |error| {
+                CompilationError::ComptimeError(reason.to_macro_error(error))
+            });
+        };
+
+        self.errors.extend(errors);
         result
     }
 
@@ -346,7 +356,7 @@ impl<'context> Elaborator<'context> {
             for item in items {
                 elaborator.add_item(item, generated_items, location);
             }
-        })
+        });
     }
 
     pub(crate) fn add_item(
@@ -557,7 +567,7 @@ impl<'context> Elaborator<'context> {
             if !generated_items.is_empty() {
                 let reason = ElaborateReason::RunningAttribute(location);
                 self.with_elaborate_reason(reason, |elaborator| {
-                    elaborator.elaborate_items(generated_items)
+                    elaborator.elaborate_items(generated_items);
                 });
             }
         }

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

@@ -10,7 +10,7 @@ use rustc_hash::FxHashMap as HashMap;
 
 use crate::TypeVariable;
 use crate::ast::{BinaryOpKind, FunctionKind, IntegerBitSize, Signedness, UnaryOp};
-use crate::elaborator::Elaborator;
+use crate::elaborator::{ElaborateReason, Elaborator};
 use crate::graph::CrateId;
 use crate::hir::def_map::ModuleId;
 use crate::hir::type_check::TypeCheckError;
@@ -191,7 +191,7 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
             Some(body) => Ok(body),
             None => {
                 if matches!(&meta.function_body, FunctionBody::Unresolved(..)) {
-                    self.elaborate_in_function(None, |elaborator| {
+                    self.elaborate_in_function(None, None, |elaborator| {
                         elaborator.elaborate_function(function);
                     });
 
@@ -207,21 +207,23 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
     fn elaborate_in_function<T>(
         &mut self,
         function: Option<FuncId>,
+        reason: Option<ElaborateReason>,
         f: impl FnOnce(&mut Elaborator) -> T,
     ) -> T {
         self.unbind_generics_from_previous_function();
-        let result = self.elaborator.elaborate_item_from_comptime_in_function(function, f);
+        let result = self.elaborator.elaborate_item_from_comptime_in_function(function, reason, f);
         self.rebind_generics_from_previous_function();
         result
     }
 
     fn elaborate_in_module<T>(
         &mut self,
         module: ModuleId,
+        reason: Option<ElaborateReason>,
         f: impl FnOnce(&mut Elaborator) -> T,
     ) -> T {
         self.unbind_generics_from_previous_function();
-        let result = self.elaborator.elaborate_item_from_comptime_in_module(module, f);
+        let result = self.elaborator.elaborate_item_from_comptime_in_module(module, reason, f);
         self.rebind_generics_from_previous_function();
         result
     }
@@ -1325,9 +1327,10 @@ impl<'local, 'interner> Interpreter<'local, 'interner> {
                 let mut result = self.call_function(function_id, arguments, bindings, location)?;
                 if call.is_macro_call {
                     let expr = result.into_expression(self.elaborator, location)?;
-                    let expr = self.elaborate_in_function(self.current_function, |elaborator| {
-                        elaborator.elaborate_expression(expr).0
-                    });
+                    let expr =
+                        self.elaborate_in_function(self.current_function, None, |elaborator| {
+                            elaborator.elaborate_expression(expr).0
+                        });
                     result = self.evaluate(expr)?;
 
                     // Macro calls are typed as type variables during type checking.

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

@@ -833,12 +833,10 @@ 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 reason = Some(ElaborateReason::EvaluatingComptimeCall("Quoted::as_module", location));
         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)
-                })
+            interpreter.elaborate_in_function(interpreter.current_function, reason, |elaborator| {
+                elaborator.resolve_module_by_path(path)
             });
         module.map(Value::ModuleDefinition)
     });
@@ -859,13 +857,11 @@ fn quoted_as_trait_constraint(
         Parser::parse_trait_bound_or_error,
         "a trait constraint",
     )?;
+    let reason =
+        Some(ElaborateReason::EvaluatingComptimeCall("Quoted::as_trait_constraint", location));
     let bound = interpreter
-        .elaborate_in_function(interpreter.current_function, |elaborator| {
-            let reason =
-                ElaborateReason::EvaluatingComptimeCall("Quoted::as_trait_constraint", location);
-            elaborator.with_elaborate_reason(reason, |elaborator| {
-                elaborator.resolve_trait_bound(&trait_bound)
-            })
+        .elaborate_in_function(interpreter.current_function, reason, |elaborator| {
+            elaborator.resolve_trait_bound(&trait_bound)
         })
         .ok_or(InterpreterError::FailedToResolveTraitBound { trait_bound, location })?;
 
@@ -880,10 +876,11 @@ 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, |elaborator| {
-        let reason = ElaborateReason::EvaluatingComptimeCall("Quoted::as_type", location);
-        elaborator.with_elaborate_reason(reason, |elaborator| elaborator.resolve_type(typ))
-    });
+    let reason = Some(ElaborateReason::EvaluatingComptimeCall("Quoted::as_type", location));
+    let typ =
+        interpreter.elaborate_in_function(interpreter.current_function, reason, |elaborator| {
+            elaborator.resolve_type(typ)
+        });
     Ok(Value::Type(typ))
 }
 
@@ -2301,37 +2298,34 @@ fn expr_resolve(
         interpreter.current_function
     };
 
-    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)))
-            }
-            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);
+    let reason = Some(ElaborateReason::EvaluatingComptimeCall("Expr::resolve", location));
+    interpreter.elaborate_in_function(function_to_resolve_in, 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)))
+        }
+        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 })
             }
-            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 })
-                }
-            }
-        })
+        }
     })
 }
 
@@ -2440,13 +2434,14 @@ fn function_def_as_typed_expr(
     let hir_expr = HirExpression::Ident(hir_ident.clone(), generics.clone());
     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| {
-        let reason =
-            ElaborateReason::EvaluatingComptimeCall("FunctionDefinition::as_typed_expr", location);
-        elaborator.with_elaborate_reason(reason, |elaborator| {
+    let reason = Some(ElaborateReason::EvaluatingComptimeCall(
+        "FunctionDefinition::as_typed_expr",
+        location,
+    ));
+    let typ =
+        interpreter.elaborate_in_function(interpreter.current_function, 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)))
 }
@@ -2652,20 +2647,17 @@ fn function_def_set_parameters(
             "a pattern",
         )?;
 
-        let hir_pattern = interpreter.elaborate_in_function(Some(func_id), |elaborator| {
-            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
-                )
-            })
+        let reason =
+            ElaborateReason::EvaluatingComptimeCall("FunctionDefinition::set_parameters", location);
+        let reason = Some(reason);
+        let hir_pattern = interpreter.elaborate_in_function(Some(func_id), 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));
@@ -2773,19 +2765,17 @@ fn module_add_item(
     let parser = Parser::parse_top_level_items;
     let top_level_statements = parse(interpreter.elaborator, item, parser, "a top-level item")?;
 
-    interpreter.elaborate_in_module(module_id, |elaborator| {
-        let reason = ElaborateReason::EvaluatingComptimeCall("Module::add_item", location);
-        elaborator.with_elaborate_reason(reason, |elaborator| {
-            let mut generated_items = CollectedItems::default();
+    let reason = Some(ElaborateReason::EvaluatingComptimeCall("Module::add_item", location));
+    interpreter.elaborate_in_module(module_id, 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);
-            }
+        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);
-            }
-        });
+        if !generated_items.is_empty() {
+            elaborator.elaborate_items(generated_items);
+        }
     });
 
     Ok(Value::Unit)