feat: Add experimental quote expression to parser

compiler/noirc_frontend/src/ast/expression.rs

@@ -27,6 +27,7 @@ pub enum ExpressionKind {
     Tuple(Vec<Expression>),
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
+    Quote(BlockExpression),
     Error,
 }
 
@@ -495,6 +496,7 @@ impl Display for ExpressionKind {
             }
             Lambda(lambda) => lambda.fmt(f),
             Parenthesized(sub_expr) => write!(f, "({sub_expr})"),
+            Quote(block) => write!(f, "quote {block}"),
             Error => write!(f, "Error"),
         }
     }

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

@@ -1085,6 +1085,7 @@ impl<'a> Resolver<'a> {
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::TraitAsType(..)
+            | Type::Code
             | Type::Forall(_, _) => (),
 
             Type::Array(length, element_type) => {
@@ -1620,6 +1621,9 @@ impl<'a> Resolver<'a> {
                 })
             }),
             ExpressionKind::Parenthesized(sub_expr) => return self.resolve_expression(*sub_expr),
+
+            // The quoted expression isn't resolved since we don't want errors if variables aren't defined
+            ExpressionKind::Quote(block) => HirExpression::Quote(block),
         };
 
         // If these lines are ever changed, make sure to change the early return

compiler/noirc_frontend/src/hir/type_check/expr.rs

@@ -332,6 +332,7 @@ impl<'interner> TypeChecker<'interner> {
 
                 Type::Function(params, Box::new(lambda.return_type), Box::new(env_type))
             }
+            HirExpression::Quote(_) => Type::Code,
         };
 
         self.interner.push_expr_type(*expr_id, typ.clone());

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -31,6 +31,7 @@ pub enum HirExpression {
     Tuple(Vec<ExprId>),
     Lambda(HirLambda),
     Error,
+    Quote(crate::BlockExpression),
 }
 
 impl HirExpression {

compiler/noirc_frontend/src/hir_def/types.rs

@@ -101,6 +101,9 @@
     /// bind to an integer without special checks to bind it to a non-type.
     Constant(u64),
 
+    /// The type of quoted code in macros. This is always a comptime-only type
+    Code,
+
     /// The result of some type error. Remembering type errors as their own type variant lets
     /// us avoid issuing repeat type errors for the same item. For example, a lambda with
     /// an invalid type would otherwise issue a new error each time it is called
@@ -144,6 +147,7 @@
             | Type::MutableReference(_)
             | Type::Forall(_, _)
             | Type::Constant(_)
+            | Type::Code
             | Type::Slice(_)
             | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
@@ -626,6 +630,7 @@
             | Type::Constant(_)
             | Type::NamedGeneric(_, _)
             | Type::Forall(_, _)
+            | Type::Code
             | Type::TraitAsType(..) => false,
 
             Type::Array(length, elem) => {
@@ -689,6 +694,7 @@
             | Type::Function(_, _, _)
             | Type::MutableReference(_)
             | Type::Forall(_, _)
+            | Type::Code
             | Type::Slice(_)
             | Type::TraitAsType(..) => false,
 
@@ -852,6 +858,7 @@
             Type::MutableReference(element) => {
                 write!(f, "&mut {element}")
             }
+            Type::Code => write!(f, "Code"),
         }
     }
 }
@@ -1503,7 +1510,7 @@
                 Type::Tuple(fields)
             }
             Type::Forall(typevars, typ) => {
                 // Trying to substitute_helper a variable de, substitute_bound_typevarsfined within a nested Forall
                 // is usually impossible and indicative of an error in the type checker somewhere.
                 for var in typevars {
                     assert!(!type_bindings.contains_key(&var.id()));
@@ -1529,6 +1536,7 @@
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
+            | Type::Code
             | Type::Unit => self.clone(),
         }
     }
@@ -1570,6 +1578,7 @@
             | Type::Constant(_)
             | Type::TraitAsType(..)
             | Type::Error
+            | Type::Code
             | Type::Unit => false,
         }
     }
@@ -1621,7 +1630,7 @@
 
             // Expect that this function should only be called on instantiated types
             Forall(..) => unreachable!(),
-            TraitAsType(..) | FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Error => {
+            TraitAsType(..) | FieldElement | Integer(_, _) | Bool | Constant(_) | Unit | Code | Error => {
                 self.clone()
             }
         }
@@ -1752,6 +1761,8 @@
             Type::MutableReference(typ) => {
                 PrintableType::MutableReference { typ: Box::new(typ.as_ref().into()) }
             }
+            // Is this actually unreachable?
+            Type::Code => unreachable!(),
         }
     }
 }
@@ -1836,6 +1847,7 @@
             Type::MutableReference(element) => {
                 write!(f, "&mut {element:?}")
             }
+            Type::Code => write!(f, "Code"),
         }
     }
 }

compiler/noirc_frontend/src/lexer/token.rs

@@ -667,6 +667,7 @@ pub enum Keyword {
     Mod,
     Mut,
     Pub,
+    Quote,
     Return,
     ReturnData,
     String,
@@ -710,6 +711,7 @@ impl fmt::Display for Keyword {
             Keyword::Mod => write!(f, "mod"),
             Keyword::Mut => write!(f, "mut"),
             Keyword::Pub => write!(f, "pub"),
+            Keyword::Quote => write!(f, "quote"),
             Keyword::Return => write!(f, "return"),
             Keyword::ReturnData => write!(f, "return_data"),
             Keyword::String => write!(f, "str"),
@@ -756,6 +758,7 @@ impl Keyword {
             "mod" => Keyword::Mod,
             "mut" => Keyword::Mut,
             "pub" => Keyword::Pub,
+            "quote" => Keyword::Quote,
             "return" => Keyword::Return,
             "return_data" => Keyword::ReturnData,
             "str" => Keyword::String,

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -516,6 +516,7 @@ impl<'interner> Monomorphizer<'interner> {
                 unreachable!("Encountered HirExpression::MethodCall during monomorphization {hir_method_call:?}")
             }
             HirExpression::Error => unreachable!("Encountered Error node during monomorphization"),
+            HirExpression::Quote(_) => unreachable!("quote expression remaining in runtime code"),
         };
 
         Ok(expr)
@@ -954,6 +955,7 @@ impl<'interner> Monomorphizer<'interner> {
             HirType::Forall(_, _) | HirType::Constant(_) | HirType::Error => {
                 unreachable!("Unexpected type {} found", typ)
             }
+            HirType::Code => unreachable!("Tried to translate Code type into runtime code"),
         }
     }
 

compiler/noirc_frontend/src/node_interner.rs

@@ -6,9 +6,9 @@
 use fm::FileId;
 use iter_extended::vecmap;
 use noirc_errors::{Location, Span, Spanned};
 use petgraph::algo::tarjan_scc;
 use petgraph::prelude::DiGraph;
 use petgraph::prelude::NodeIndex as PetGraphIndex;
 
 use crate::ast::Ident;
 use crate::graph::CrateId;
@@ -1672,6 +1672,7 @@
     Tuple,
     Function,
     Generic,
+    Code,
 }
 
 fn get_type_method_key(typ: &Type) -> Option<TypeMethodKey> {
@@ -1691,6 +1692,7 @@
         Type::Tuple(_) => Some(Tuple),
         Type::Function(_, _, _) => Some(Function),
         Type::NamedGeneric(_, _) => Some(Generic),
+        Type::Code => Some(Code),
         Type::MutableReference(element) => get_type_method_key(element),
         Type::Alias(alias, _) => get_type_method_key(&alias.borrow().typ),
 

compiler/noirc_frontend/src/parser/parser.rs

@@ -1150,7 +1150,8 @@ where
             nothing().boxed()
         },
         lambdas::lambda(expr_parser.clone()),
-        block(statement).map(ExpressionKind::Block),
+        block(statement.clone()).map(ExpressionKind::Block),
+        quote(statement),
         variable(),
         literal(),
     ))
@@ -1175,6 +1176,19 @@ where
         .labelled(ParsingRuleLabel::Atom)
 }
 
+fn quote<'a, P>(statement: P) -> impl NoirParser<ExpressionKind> + 'a
+where
+    P: NoirParser<StatementKind> + 'a,
+{
+    keyword(Keyword::Quote).ignore_then(block(statement)).validate(|block, span, emit| {
+        emit(ParserError::with_reason(
+            ParserErrorReason::ExperimentalFeature("quoted expressions"),
+            span,
+        ));
+        ExpressionKind::Quote(block)
+    })
+}
+
 fn tuple<P>(expr_parser: P) -> impl NoirParser<Expression>
 where
     P: ExprParser,

tooling/nargo_fmt/src/rewrite/expr.rs

@@ -1,4 +1,7 @@
-use noirc_frontend::{token::Token, ArrayLiteral, Expression, ExpressionKind, Literal, UnaryOp};
+use noirc_frontend::{
+    macros_api::Span, token::Token, ArrayLiteral, BlockExpression, Expression, ExpressionKind,
+    Literal, UnaryOp,
+};
 
 use crate::visitor::{
     expr::{format_brackets, format_parens, NewlineMode},
@@ -20,11 +23,7 @@ pub(crate) fn rewrite(
     shape: Shape,
 ) -> String {
     match kind {
-        ExpressionKind::Block(block) => {
-            let mut visitor = visitor.fork();
-            visitor.visit_block(block, span);
-            visitor.finish()
-        }
+        ExpressionKind::Block(block) => rewrite_block(visitor, block, span),
         ExpressionKind::Prefix(prefix) => {
             let op = match prefix.operator {
                 UnaryOp::Minus => "-",
@@ -159,6 +158,13 @@ pub(crate) fn rewrite(
             visitor.format_if(*if_expr)
         }
         ExpressionKind::Lambda(_) | ExpressionKind::Variable(_) => visitor.slice(span).to_string(),
+        ExpressionKind::Quote(block) => format!("quote {}", rewrite_block(visitor, block, span)),
         ExpressionKind::Error => unreachable!(),
     }
 }
+
+fn rewrite_block(visitor: &FmtVisitor, block: BlockExpression, span: Span) -> String {
+    let mut visitor = visitor.fork();
+    visitor.visit_block(block, span);
+    visitor.finish()
+}

tooling/noirc_abi/src/lib.rs

@@ -178,8 +178,9 @@ impl AbiType {
             | Type::TypeVariable(_, _)
             | Type::NamedGeneric(..)
             | Type::Forall(..)
+            | Type::Code
             | Type::Slice(_)
-            | Type::Function(_, _, _) => unreachable!("Type cannot be used in the abi"),
+            | Type::Function(_, _, _) => unreachable!("{typ} cannot be used in the abi"),
             Type::FmtString(_, _) => unreachable!("format strings cannot be used in the abi"),
             Type::MutableReference(_) => unreachable!("&mut cannot be used in the abi"),
         }