feat: add std::warn::warn

Author: asterite

compiler/noirc_frontend/src/elaborator/patterns.rs

@@ -20,6 +20,7 @@ use crate::{
     node_interner::{
         DefinitionId, DefinitionInfo, DefinitionKind, ExprId, FuncId, GlobalId, TraitImplKind,
     },
+    token::FunctionAttribute,
 };
 
 use super::{Elaborator, ResolverMeta, path_resolution::PathResolutionItem};
@@ -572,6 +573,8 @@ impl Elaborator<'_> {
             }
         }
 
+        self.check_call_to_warn_builtin_at_runtime(&definition_kind, location);
+
         let id = self.interner.push_expr(HirExpression::Ident(expr.clone(), generics.clone()));
 
         self.interner.push_expr_location(id, location);
@@ -597,6 +600,28 @@ impl Elaborator<'_> {
         }
     }
 
+    // It's an error to call to the built-in function "warn" if we are not in a comptime context
+    fn check_call_to_warn_builtin_at_runtime(
+        &mut self,
+        definition_kind: &Option<DefinitionKind>,
+        location: Location,
+    ) {
+        let Some(DefinitionKind::Function(func_id)) = definition_kind else {
+            return;
+        };
+
+        if self.in_comptime_context() {
+            return;
+        }
+
+        let attribute = self.interner.function_attributes(func_id).function();
+        if let Some(FunctionAttribute::Builtin(builtin)) = attribute {
+            if builtin == "warn" {
+                self.push_err(ResolverError::WarnUsedAtRuntime { location });
+            }
+        }
+    }
+
     /// Solve any generics that are part of the path before the function, for example:
     ///
     /// foo::Bar::<i32>::baz

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

@@ -256,6 +256,10 @@ pub enum InterpreterError {
     LoopHaltedForUiResponsiveness {
         location: Location,
     },
+    Warning {
+        message: String,
+        location: Location,
+    },
 
     // These cases are not errors, they are just used to prevent us from running more code
     // until the loop can be resumed properly. These cases will never be displayed to users.
@@ -331,7 +335,8 @@ impl InterpreterError {
             | InterpreterError::UnknownArrayLength { location, .. }
             | InterpreterError::CannotInterpretFormatStringWithErrors { location }
             | InterpreterError::GlobalsDependencyCycle { location }
-            | InterpreterError::LoopHaltedForUiResponsiveness { location } => *location,
+            | InterpreterError::LoopHaltedForUiResponsiveness { location }
+            | InterpreterError::Warning { location, .. } => *location,
 
             InterpreterError::FailedToParseMacro { error, .. } => error.location(),
             InterpreterError::NoMatchingImplFound { error } => error.location,
@@ -695,6 +700,9 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                     "This error doesn't happen in normal executions of `nargo`".to_string();
                 CustomDiagnostic::simple_warning(msg, secondary, *location)
             }
+            InterpreterError::Warning { message, location } => {
+                CustomDiagnostic::simple_warning(message.into(), String::new(), *location)
+            }
         }
     }
 }

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

@@ -248,6 +248,7 @@ impl Interpreter<'_, '_> {
             "unresolved_type_is_bool" => unresolved_type_is_bool(interner, arguments, location),
             "unresolved_type_is_field" => unresolved_type_is_field(interner, arguments, location),
             "unresolved_type_is_unit" => unresolved_type_is_unit(interner, arguments, location),
+            "warn" => warn(self.elaborator, arguments, location),
             "zeroed" => Ok(zeroed(return_type, location)),
             _ => {
                 let item = format!("Comptime evaluation for builtin function '{name}'");
@@ -1403,6 +1404,18 @@ where
     Ok(option(return_type, option_value, location))
 }
 
+// fn warn<T, let N: u32>(message: fmtstr<N, T>) {}
+fn warn(
+    elaborator: &mut Elaborator,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let message = check_one_argument(arguments, location)?;
+    let (message, _) = get_format_string(elaborator.interner, message)?;
+    elaborator.push_err(InterpreterError::Warning { message: message.to_string(), location });
+    Ok(Value::Unit)
+}
+
 // fn zeroed<T>() -> T
 fn zeroed(return_type: Type, location: Location) -> Value {
     match return_type {

compiler/noirc_frontend/src/hir/resolution/errors.rs

@@ -192,6 +192,8 @@ pub enum ResolverError {
     UnexpectedItemInPattern { location: Location, item: &'static str },
     #[error("Trait `{trait_name}` doesn't have a method named `{method_name}`")]
     NoSuchMethodInTrait { trait_name: String, method_name: String, location: Location },
+    #[error("The `std::warn::warn` function cannot be called at runtime")]
+    WarnUsedAtRuntime { location: Location },
 }
 
 impl ResolverError {
@@ -255,9 +257,8 @@ impl ResolverError {
             | ResolverError::TypeUnsupportedInMatch { location, .. }
             | ResolverError::UnexpectedItemInPattern { location, .. }
             | ResolverError::NoSuchMethodInTrait { location, .. }
-            | ResolverError::VariableAlreadyDefinedInPattern { new_location: location, .. } => {
-                *location
-            }
+            | ResolverError::VariableAlreadyDefinedInPattern { new_location: location, .. }
+            | ResolverError::WarnUsedAtRuntime { location } => *location,
             ResolverError::UnusedVariable { ident }
             | ResolverError::UnusedItem { ident, .. }
             | ResolverError::DuplicateField { field: ident }
@@ -801,6 +802,13 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                     *location,
                 )
             },
+            ResolverError::WarnUsedAtRuntime {location } => {
+                Diagnostic::simple_error(
+                    "The `std::warn::warn` function cannot be called at runtime".to_string(),
+                    "This function can only be called in comptime code".to_string(),
+                    *location,
+                )
+            },
         }
     }
 }

noir_stdlib/src/lib.nr

@@ -22,6 +22,7 @@ pub mod append;
 pub mod mem;
 pub mod panic;
 pub mod hint;
+pub mod warn;
 
 use convert::AsPrimitive;
 

noir_stdlib/src/warn.nr

@@ -0,0 +1,5 @@
+/// Produces a warning during compilation.
+///
+/// Note: this function cannot be used at runtime.
+#[builtin(warn)]
+pub comptime fn warn<T, let N: u32>(message: fmtstr<N, T>) {}