chore(experimental): Add scan pass and into_expression for comptime interpreter

compiler/noirc_frontend/src/ast/expression.rs

@@ -28,6 +28,7 @@ pub enum ExpressionKind {
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
     Quote(BlockExpression),
+    CompTime(BlockExpression),
     Error,
 }
 
@@ -504,6 +505,7 @@ impl Display for ExpressionKind {
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
             Quote(block) => write!(f, "quote {block}"),
+            CompTime(block) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
         }
     }

compiler/noirc_frontend/src/ast/statement.rs

@@ -40,7 +40,7 @@ pub enum StatementKind {
     Break,
     Continue,
     /// This statement should be executed at compile-time
-    Comptime(Box<StatementKind>),
+    CompTime(Box<StatementKind>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
     // This statement is the result of a recovered parse error.
@@ -87,10 +87,10 @@ impl StatementKind {
                 }
                 self
             }
-            StatementKind::Comptime(mut statement) => {
+            StatementKind::CompTime(mut statement) => {
                 *statement =
                     statement.add_semicolon(semi, span, last_statement_in_block, emit_error);
-                StatementKind::Comptime(statement)
+                StatementKind::CompTime(statement)
             }
             // A semicolon on a for loop is optional and does nothing
             StatementKind::For(_) => self,
@@ -685,7 +685,7 @@ impl Display for StatementKind {
             StatementKind::For(for_loop) => for_loop.fmt(f),
             StatementKind::Break => write!(f, "break"),
             StatementKind::Continue => write!(f, "continue"),
-            StatementKind::Comptime(statement) => write!(f, "comptime {statement}"),
+            StatementKind::CompTime(statement) => write!(f, "comptime {statement}"),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
             StatementKind::Error => write!(f, "Error"),
         }

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

@@ -0,0 +1,54 @@
+use crate::{node_interner::DefinitionId, Type};
+use acvm::FieldElement;
+use noirc_errors::Location;
+
+use super::value::Value;
+
+/// The possible errors that can halt the interpreter.
+#[allow(unused)]
+#[derive(Debug)]
+pub(crate) enum InterpreterError {
+    ArgumentCountMismatch { expected: usize, actual: usize, call_location: Location },
+    TypeMismatch { expected: Type, value: Value, location: Location },
+    NoValueForId { id: DefinitionId, location: Location },
+    IntegerOutOfRangeForType { value: FieldElement, typ: Type, location: Location },
+    ErrorNodeEncountered { location: Location },
+    NonFunctionCalled { value: Value, location: Location },
+    NonBoolUsedInIf { value: Value, location: Location },
+    NonBoolUsedInConstrain { value: Value, location: Location },
+    FailingConstraint { message: Option<Value>, location: Location },
+    NoMethodFound { object: Value, typ: Type, location: Location },
+    NonIntegerUsedInLoop { value: Value, location: Location },
+    NonPointerDereferenced { value: Value, location: Location },
+    NonTupleOrStructInMemberAccess { value: Value, location: Location },
+    NonArrayIndexed { value: Value, location: Location },
+    NonIntegerUsedAsIndex { value: Value, location: Location },
+    NonIntegerIntegerLiteral { typ: Type, location: Location },
+    NonIntegerArrayLength { typ: Type, location: Location },
+    NonNumericCasted { value: Value, location: Location },
+    IndexOutOfBounds { index: usize, length: usize, location: Location },
+    ExpectedStructToHaveField { value: Value, field_name: String, location: Location },
+    TypeUnsupported { typ: Type, location: Location },
+    InvalidValueForUnary { value: Value, operator: &'static str, location: Location },
+    InvalidValuesForBinary { lhs: Value, rhs: Value, operator: &'static str, location: Location },
+    CastToNonNumericType { typ: Type, location: Location },
+    QuoteInRuntimeCode { location: Location },
+    NonStructInConstructor { typ: Type, location: Location },
+    CannotInlineMacro { value: Value, location: Location },
+    UnquoteFoundDuringEvaluation { location: Location },
+
+    Unimplemented { item: &'static str, location: Location },
+
+    // Perhaps this should be unreachable! due to type checking also preventing this error?
+    // Currently it and the Continue variant are the only interpreter errors without a Location field
+    BreakNotInLoop,
+    ContinueNotInLoop,
+
+    // These cases are not errors but prevent us from running more code
+    // until the loop can be resumed properly.
+    Break,
+    Continue,
+}
+
+#[allow(unused)]
+pub(super) type IResult<T> = std::result::Result<T, InterpreterError>;

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

@@ -9,7 +9,7 @@ use crate::ast::{
     UnresolvedTypeData, UnresolvedTypeExpression,
 };
 use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
-use crate::hir_def::expr::{HirArrayLiteral, HirExpression, HirIdent};
+use crate::hir_def::expr::{HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent};
 use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
 use crate::hir_def::types::Type;
 use crate::macros_api::HirLiteral;
@@ -26,7 +26,7 @@ impl StmtId {
     #[allow(unused)]
     fn to_ast(self, interner: &NodeInterner) -> Statement {
         let statement = interner.statement(&self);
-        let span = interner.statement_span(&self);
+        let span = interner.statement_span(self);
 
         let kind = match statement {
             HirStatement::Let(let_stmt) => {
@@ -66,8 +66,8 @@ impl StmtId {
             HirStatement::Expression(expr) => StatementKind::Expression(expr.to_ast(interner)),
             HirStatement::Semi(expr) => StatementKind::Semi(expr.to_ast(interner)),
             HirStatement::Error => StatementKind::Error,
-            HirStatement::Comptime(statement) => {
-                StatementKind::Comptime(Box::new(statement.to_ast(interner).kind))
+            HirStatement::CompTime(statement) => {
+                StatementKind::CompTime(Box::new(statement.to_ast(interner).kind))
             }
         };
 
@@ -108,10 +108,7 @@ impl ExprId {
                 ExpressionKind::Literal(Literal::FmtStr(string))
             }
             HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
-            HirExpression::Block(expr) => {
-                let statements = vecmap(expr.statements, |statement| statement.to_ast(interner));
-                ExpressionKind::Block(BlockExpression { statements })
-            }
+            HirExpression::Block(expr) => ExpressionKind::Block(expr.into_ast(interner)),
             HirExpression::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
                 operator: prefix.operator,
                 rhs: prefix.rhs.to_ast(interner),
@@ -172,8 +169,12 @@ impl ExprId {
                 let body = lambda.body.to_ast(interner);
                 ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
             }
-            HirExpression::Quote(block) => ExpressionKind::Quote(block),
             HirExpression::Error => ExpressionKind::Error,
+            HirExpression::CompTime(block) => ExpressionKind::CompTime(block.into_ast(interner)),
+            HirExpression::Quote(block) => ExpressionKind::Quote(block),
+
+            // A macro was evaluated here!
+            HirExpression::Unquote(block) => ExpressionKind::Block(block),
         };
 
         Expression::new(kind, span)
@@ -353,3 +354,10 @@ impl HirArrayLiteral {
         }
     }
 }
+
+impl HirBlockExpression {
+    fn into_ast(self, interner: &NodeInterner) -> BlockExpression {
+        let statements = vecmap(self.statements, |statement| statement.to_ast(interner));
+        BlockExpression { statements }
+    }
+}