feat: add FunctionDef::body

aztec_macros/src/utils/parse_utils.rs

@@ -218,7 +218,10 @@
         StatementKind::For(for_loop_statement) => empty_for_loop_statement(for_loop_statement),
         StatementKind::Comptime(statement) => empty_statement(statement),
         StatementKind::Semi(expression) => empty_expression(expression),
-        StatementKind::Break | StatementKind::Continue | StatementKind::Error => (),
+        StatementKind::Break
+        | StatementKind::Continue
+        | StatementKind::Interned(_)
+        | StatementKind::Error => (),
     }
 }
 
@@ -271,12 +274,15 @@
         ExpressionKind::Unsafe(block_expression, _span) => {
             empty_block_expression(block_expression);
         }
-        ExpressionKind::Quote(..) | ExpressionKind::Resolved(_) | ExpressionKind::Error => (),
         ExpressionKind::AsTraitPath(path) => {
             empty_unresolved_type(&mut path.typ);
             empty_path(&mut path.trait_path);
             empty_ident(&mut path.impl_item);
         }
+        ExpressionKind::Quote(..)
+        | ExpressionKind::Resolved(_)
+        | ExpressionKind::Interned(_)
+        | ExpressionKind::Error => (),
     }
 }
 
@@ -353,6 +359,7 @@
         | UnresolvedTypeData::Unit
         | UnresolvedTypeData::Quoted(_)
         | UnresolvedTypeData::Resolved(_)
+        | UnresolvedTypeData::Interned(_)
         | UnresolvedTypeData::Unspecified
         | UnresolvedTypeData::Error => (),
     }
@@ -397,9 +404,9 @@
 }
 
 fn empty_unresolved_trait_constraints(
     unresolved_trait_constriants: &mut [UnresolvedTraitConstraint],
 ) {
     for trait_constraint in unresolved_trait_constriants.iter_mut() {
         empty_unresolved_trait_constraint(trait_constraint);
     }
 }
@@ -531,6 +538,7 @@
             empty_expression(index);
         }
         LValue::Dereference(lvalue, _) => empty_lvalue(lvalue),
+        LValue::Interned(..) => (),
     }
 }
 

compiler/noirc_frontend/src/ast/expression.rs

@@ -7,7 +7,7 @@ use crate::ast::{
 };
 use crate::hir::def_collector::errors::DefCollectorErrorKind;
 use crate::macros_api::StructId;
-use crate::node_interner::{ExprId, QuotedTypeId};
+use crate::node_interner::{ExprId, InternedExpressionKind, QuotedTypeId};
 use crate::token::{Attributes, FunctionAttribute, Token, Tokens};
 use crate::{Kind, Type};
 use acvm::{acir::AcirField, FieldElement};
@@ -43,6 +43,11 @@ pub enum ExpressionKind {
     // code. It is used to translate function values back into the AST while
     // guaranteeing they have the same instantiated type and definition id without resolving again.
     Resolved(ExprId),
+
+    // This is an interned ExpressionKind during comptime code.
+    // The actual ExpressionKind can be retrieved with a NodeInterner.
+    Interned(InternedExpressionKind),
+
     Error,
 }
 
@@ -603,6 +608,7 @@ impl Display for ExpressionKind {
             Unsafe(block, _) => write!(f, "unsafe {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
+            Interned(_) => write!(f, "?Interned"),
             Unquote(expr) => write!(f, "$({expr})"),
             Quote(tokens) => {
                 let tokens = vecmap(&tokens.0, ToString::to_string);

compiler/noirc_frontend/src/ast/mod.rs

@@ -22,7 +22,7 @@
 pub use type_alias::*;
 
 use crate::{
-    node_interner::QuotedTypeId,
+    node_interner::{InternedUnresolvedTypeData, QuotedTypeId},
     parser::{ParserError, ParserErrorReason},
     token::IntType,
     BinaryTypeOperator,
@@ -141,6 +141,10 @@
     /// as a result of being spliced into a macro's token stream input.
     Resolved(QuotedTypeId),
 
+    // This is an interned UnresolvedTypeData during comptime code.
+    // The actual UnresolvedTypeData can be retrieved with a NodeInterner.
+    Interned(InternedUnresolvedTypeData),
+
     Unspecified, // This is for when the user declares a variable without specifying it's type
     Error,
 }
@@ -297,6 +301,7 @@
             Unspecified => write!(f, "unspecified"),
             Parenthesized(typ) => write!(f, "({typ})"),
             Resolved(_) => write!(f, "(resolved type)"),
+            Interned(_) => write!(f, "?Interned"),
             AsTraitPath(path) => write!(f, "{path}"),
         }
     }
@@ -480,7 +485,7 @@
             Self::Public => write!(f, "pub"),
             Self::Private => write!(f, "priv"),
             Self::CallData(id) => write!(f, "calldata{id}"),
             Self::ReturnData => write!(f, "returndata"),
         }
     }
 }

compiler/noirc_frontend/src/ast/statement.rs

@@ -13,6 +13,7 @@ use super::{
 use crate::elaborator::types::SELF_TYPE_NAME;
 use crate::lexer::token::SpannedToken;
 use crate::macros_api::{SecondaryAttribute, UnresolvedTypeData};
+use crate::node_interner::{InternedExpressionKind, InternedStatementKind};
 use crate::parser::{ParserError, ParserErrorReason};
 use crate::token::Token;
 
@@ -45,6 +46,9 @@ pub enum StatementKind {
     Comptime(Box<Statement>),
     // This is an expression with a trailing semi-colon
     Semi(Expression),
+    // This is an interned StatementKind during comptime code.
+    // The actual StatementKind can be retrieved with a NodeInterner.
+    Interned(InternedStatementKind),
     // This statement is the result of a recovered parse error.
     // To avoid issuing multiple errors in later steps, it should
     // be skipped in any future analysis if possible.
@@ -97,6 +101,9 @@ impl StatementKind {
             // A semicolon on a for loop is optional and does nothing
             StatementKind::For(_) => self,
 
+            // No semicolon needed for a resolved statement
+            StatementKind::Interned(_) => self,
+
             StatementKind::Expression(expr) => {
                 match (&expr.kind, semi, last_statement_in_block) {
                     // Semicolons are optional for these expressions
@@ -534,6 +541,7 @@ pub enum LValue {
     MemberAccess { object: Box<LValue>, field_name: Ident, span: Span },
     Index { array: Box<LValue>, index: Expression, span: Span },
     Dereference(Box<LValue>, Span),
+    Interned(InternedExpressionKind, Span),
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -591,7 +599,7 @@ impl Recoverable for Pattern {
 }
 
 impl LValue {
-    fn as_expression(&self) -> Expression {
+    pub fn as_expression(&self) -> Expression {
         let kind = match self {
             LValue::Ident(ident) => ExpressionKind::Variable(Path::from_ident(ident.clone())),
             LValue::MemberAccess { object, field_name, span: _ } => {
@@ -612,17 +620,53 @@ impl LValue {
                     rhs: lvalue.as_expression(),
                 }))
             }
+            LValue::Interned(id, _) => ExpressionKind::Interned(*id),
         };
         let span = self.span();
         Expression::new(kind, span)
     }
 
+    pub fn from_expression(expr: Expression) -> LValue {
+        LValue::from_expression_kind(expr.kind, expr.span)
+    }
+
+    pub fn from_expression_kind(expr: ExpressionKind, span: Span) -> LValue {
+        match expr {
+            ExpressionKind::Variable(path) => LValue::Ident(path.as_ident().unwrap().clone()),
+            ExpressionKind::MemberAccess(member_access) => LValue::MemberAccess {
+                object: Box::new(LValue::from_expression(member_access.lhs)),
+                field_name: member_access.rhs,
+                span,
+            },
+            ExpressionKind::Index(index) => LValue::Index {
+                array: Box::new(LValue::from_expression(index.collection)),
+                index: index.index,
+                span,
+            },
+            ExpressionKind::Prefix(prefix) => {
+                if matches!(
+                    prefix.operator,
+                    crate::ast::UnaryOp::Dereference { implicitly_added: false }
+                ) {
+                    LValue::Dereference(Box::new(LValue::from_expression(prefix.rhs)), span)
+                } else {
+                    panic!("Called LValue::from_expression with an invalid prefix operator")
+                }
+            }
+            ExpressionKind::Interned(id) => LValue::Interned(id, span),
+            _ => {
+                panic!("Called LValue::from_expression with an invalid expression")
+            }
+        }
+    }
+
     pub fn span(&self) -> Span {
         match self {
             LValue::Ident(ident) => ident.span(),
             LValue::MemberAccess { span, .. }
             | LValue::Index { span, .. }
             | LValue::Dereference(_, span) => *span,
+            LValue::Interned(_, span) => *span,
         }
     }
 }
@@ -777,6 +821,7 @@ impl Display for StatementKind {
             StatementKind::Continue => write!(f, "continue"),
             StatementKind::Comptime(statement) => write!(f, "comptime {}", statement.kind),
             StatementKind::Semi(semi) => write!(f, "{semi};"),
+            StatementKind::Interned(_) => write!(f, "(resolved);"),
             StatementKind::Error => write!(f, "Error"),
         }
     }
@@ -809,6 +854,7 @@ impl Display for LValue {
             }
             LValue::Index { array, index, span: _ } => write!(f, "{array}[{index}]"),
             LValue::Dereference(lvalue, _span) => write!(f, "*{lvalue}"),
+            LValue::Interned(_, _) => write!(f, "?Interned"),
         }
     }
 }

compiler/noirc_frontend/src/debug/mod.rs

@@ -291,7 +291,7 @@
             }
             ast::LValue::Dereference(_lv, span) => {
                 // TODO: this is a dummy statement for now, but we should
                 // somehow track the derefence and update the pointed to
                 // variable
                 ast::Statement {
                     kind: ast::StatementKind::Expression(uint_expr(0, *span)),
@@ -322,6 +322,9 @@
                         ast::LValue::Dereference(_ref, _span) => {
                             unimplemented![]
                         }
+                        ast::LValue::Interned(..) => {
+                            unimplemented![]
+                        }
                     }
                 }
                 build_assign_member_stmt(
@@ -674,9 +677,9 @@
             ast::Pattern::Tuple(patterns, _) => {
                 stack.extend(patterns.iter().map(|pattern| (pattern, false)));
             }
             ast::Pattern::Struct(_, pids, _) => {
                 stack.extend(pids.iter().map(|(_, pattern)| (pattern, is_mut)));
                 vars.extend(pids.iter().map(|(id, _)| (id.clone(), false)));
             }
         }
     }
@@ -686,7 +689,7 @@
 fn pattern_to_string(pattern: &ast::Pattern) -> String {
     match pattern {
         ast::Pattern::Identifier(id) => id.0.contents.clone(),
         ast::Pattern::Mutable(mpat, _, _) => format!("mut {}", pattern_to_string(mpat.as_ref())),
         ast::Pattern::Tuple(elements, _) => format!(
             "({})",
             elements.iter().map(pattern_to_string).collect::<Vec<String>>().join(", ")

compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -62,6 +62,11 @@ impl<'context> Elaborator<'context> {
                 self.elaborate_unsafe_block(block_expression)
             }
             ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),
+            ExpressionKind::Interned(id) => {
+                let expr_kind = self.interner.get_expression_kind(id);
+                let expr = Expression::new(expr_kind.clone(), expr.span);
+                return self.elaborate_expression(expr);
+            }
             ExpressionKind::Error => (HirExpression::Error, Type::Error),
             ExpressionKind::Unquote(_) => {
                 self.push_err(ResolverError::UnquoteUsedOutsideQuote { span: expr.span });

compiler/noirc_frontend/src/elaborator/statements.rs

@@ -39,6 +39,11 @@ impl<'context> Elaborator<'context> {
                 let (expr, _typ) = self.elaborate_expression(expr);
                 (HirStatement::Semi(expr), Type::Unit)
             }
+            StatementKind::Interned(id) => {
+                let kind = self.interner.get_statement_kind(id);
+                let statement = Statement { kind: kind.clone(), span: statement.span };
+                self.elaborate_statement_value(statement)
+            }
             StatementKind::Error => (HirStatement::Error, Type::Error),
         }
     }
@@ -357,6 +362,10 @@ impl<'context> Elaborator<'context> {
                 let lvalue = HirLValue::Dereference { lvalue, element_type, location };
                 (lvalue, typ, true)
             }
+            LValue::Interned(id, span) => {
+                let lvalue = self.interner.get_lvalue(id, span).clone();
+                self.elaborate_lvalue(lvalue, assign_span)
+            }
         }
     }
 

compiler/noirc_frontend/src/elaborator/types.rs

@@ -158,6 +158,10 @@ impl<'context> Elaborator<'context> {
             Parenthesized(typ) => self.resolve_type_inner(*typ, kind),
             Resolved(id) => self.interner.get_quoted_type(id).clone(),
             AsTraitPath(path) => self.resolve_as_trait_path(*path),
+            Interned(id) => {
+                let typ = self.interner.get_unresolved_type_data(id).clone();
+                return self.resolve_type_inner(UnresolvedType { typ, span }, kind);
+            }
         };
 
         let location = Location::new(named_path_span.unwrap_or(typ.span), self.file);