feat(meta): Comptime keccak (noir-lang/noir#5854)

feat(optimization): Avoid merging identical (by ID) arrays (noir-lang/noir#5853)
feat: add `FunctionDef::body` (noir-lang/noir#5825)
fix(sha256): Fix upper bound when building msg block and delay final block compression under certain cases  (noir-lang/noir#5838)
feat: remove unnecessary copying of vector size during reversal (noir-lang/noir#5852)
chore: Add missing cases to arithmetic generics (noir-lang/noir#5841)
feat: warn on unused imports (noir-lang/noir#5847)
chore: add documentation to `to_be_bytes`, etc. (noir-lang/noir#5843)
feat: simplify constant calls to `poseidon2_permutation`, `schnorr_verify` and `embedded_curve_add` (noir-lang/noir#5140)
chore: don't require empty `Prover.toml` for programs with zero arguments but a return value (noir-lang/noir#5845)
fix!: Check unused generics are bound (noir-lang/noir#5840)
chore(perf): Simplify poseidon2 algorithm  (noir-lang/noir#5811)
chore: redo typo PR by nnsW3 (noir-lang/noir#5834)
fix(sha256): Perform compression per block and utilize ROM instead of RAM when setting up the message block (noir-lang/noir#5760)
chore(perf): Update to stdlib keccak for reduced Brillig code size (noir-lang/noir#5827)

noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_memory.rs

@@ -276,14 +276,14 @@ impl<F: AcirField + DebugToString, Registers: RegisterAllocator> BrilligContext<
         let index_at_end_of_array = self.allocate_register();
         let end_value_register = self.allocate_register();
 
-        self.mov_instruction(index_at_end_of_array, size);
+        self.mov_instruction(index_at_end_of_array, vector.size);
 
         self.codegen_loop(iteration_count, |ctx, iterator_register| {
             // The index at the end of array is size - 1 - iterator
             ctx.codegen_usize_op_in_place(index_at_end_of_array, BrilligBinaryOp::Sub, 1);
 
             // Load both values
-            ctx.codegen_array_get(pointer, iterator_register, start_value_register);
+            ctx.codegen_array_get(vector.pointer, iterator_register, start_value_register);
             ctx.codegen_array_get(
                 pointer,
                 SingleAddrVariable::new_usize(index_at_end_of_array),

noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/value.rs

@@ -633,6 +633,235 @@ impl<'value, 'interner> Display for ValuePrinter<'value, 'interner> {
     }
 }
 
+fn display_trait_constraint(interner: &NodeInterner, trait_constraint: &TraitConstraint) -> String {
+    let trait_ = interner.get_trait(trait_constraint.trait_id);
+    format!("{}: {}{}", trait_constraint.typ, trait_.name, trait_constraint.trait_generics)
+}
+
+// Returns a new Expression where all Interned and Resolved expressions have been turned into non-interned ExpressionKind.
+fn remove_interned_in_expression(interner: &NodeInterner, expr: Expression) -> Expression {
+    Expression { kind: remove_interned_in_expression_kind(interner, expr.kind), span: expr.span }
+}
+
+// Returns a new ExpressionKind where all Interned and Resolved expressions have been turned into non-interned ExpressionKind.
+fn remove_interned_in_expression_kind(
+    interner: &NodeInterner,
+    expr: ExpressionKind,
+) -> ExpressionKind {
+    match expr {
+        ExpressionKind::Literal(literal) => {
+            ExpressionKind::Literal(remove_interned_in_literal(interner, literal))
+        }
+        ExpressionKind::Block(block) => {
+            let statements =
+                vecmap(block.statements, |stmt| remove_interned_in_statement(interner, stmt));
+            ExpressionKind::Block(BlockExpression { statements })
+        }
+        ExpressionKind::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
+            rhs: remove_interned_in_expression(interner, prefix.rhs),
+            ..*prefix
+        })),
+        ExpressionKind::Index(index) => ExpressionKind::Index(Box::new(IndexExpression {
+            collection: remove_interned_in_expression(interner, index.collection),
+            index: remove_interned_in_expression(interner, index.index),
+        })),
+        ExpressionKind::Call(call) => ExpressionKind::Call(Box::new(CallExpression {
+            func: Box::new(remove_interned_in_expression(interner, *call.func)),
+            arguments: vecmap(call.arguments, |arg| remove_interned_in_expression(interner, arg)),
+            ..*call
+        })),
+        ExpressionKind::MethodCall(call) => {
+            ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                object: remove_interned_in_expression(interner, call.object),
+                arguments: vecmap(call.arguments, |arg| {
+                    remove_interned_in_expression(interner, arg)
+                }),
+                ..*call
+            }))
+        }
+        ExpressionKind::Constructor(constructor) => {
+            ExpressionKind::Constructor(Box::new(ConstructorExpression {
+                fields: vecmap(constructor.fields, |(name, expr)| {
+                    (name, remove_interned_in_expression(interner, expr))
+                }),
+                ..*constructor
+            }))
+        }
+        ExpressionKind::MemberAccess(member_access) => {
+            ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+                lhs: remove_interned_in_expression(interner, member_access.lhs),
+                ..*member_access
+            }))
+        }
+        ExpressionKind::Cast(cast) => ExpressionKind::Cast(Box::new(CastExpression {
+            lhs: remove_interned_in_expression(interner, cast.lhs),
+            ..*cast
+        })),
+        ExpressionKind::Infix(infix) => ExpressionKind::Infix(Box::new(InfixExpression {
+            lhs: remove_interned_in_expression(interner, infix.lhs),
+            rhs: remove_interned_in_expression(interner, infix.rhs),
+            ..*infix
+        })),
+        ExpressionKind::If(if_expr) => ExpressionKind::If(Box::new(IfExpression {
+            condition: remove_interned_in_expression(interner, if_expr.condition),
+            consequence: remove_interned_in_expression(interner, if_expr.consequence),
+            alternative: if_expr
+                .alternative
+                .map(|alternative| remove_interned_in_expression(interner, alternative)),
+        })),
+        ExpressionKind::Variable(_) => expr,
+        ExpressionKind::Tuple(expressions) => ExpressionKind::Tuple(vecmap(expressions, |expr| {
+            remove_interned_in_expression(interner, expr)
+        })),
+        ExpressionKind::Lambda(lambda) => ExpressionKind::Lambda(Box::new(Lambda {
+            body: remove_interned_in_expression(interner, lambda.body),
+            ..*lambda
+        })),
+        ExpressionKind::Parenthesized(expr) => {
+            ExpressionKind::Parenthesized(Box::new(remove_interned_in_expression(interner, *expr)))
+        }
+        ExpressionKind::Quote(_) => expr,
+        ExpressionKind::Unquote(expr) => {
+            ExpressionKind::Unquote(Box::new(remove_interned_in_expression(interner, *expr)))
+        }
+        ExpressionKind::Comptime(block, span) => {
+            let statements =
+                vecmap(block.statements, |stmt| remove_interned_in_statement(interner, stmt));
+            ExpressionKind::Comptime(BlockExpression { statements }, span)
+        }
+        ExpressionKind::Unsafe(block, span) => {
+            let statements =
+                vecmap(block.statements, |stmt| remove_interned_in_statement(interner, stmt));
+            ExpressionKind::Unsafe(BlockExpression { statements }, span)
+        }
+        ExpressionKind::AsTraitPath(_) => expr,
+        ExpressionKind::Resolved(id) => {
+            let expr = interner.expression(&id);
+            expr.to_display_ast(interner, Span::default()).kind
+        }
+        ExpressionKind::Interned(id) => {
+            let expr = interner.get_expression_kind(id).clone();
+            remove_interned_in_expression_kind(interner, expr)
+        }
+        ExpressionKind::Error => expr,
+    }
+}
+
+fn remove_interned_in_literal(interner: &NodeInterner, literal: Literal) -> Literal {
+    match literal {
+        Literal::Array(array_literal) => {
+            Literal::Array(remove_interned_in_array_literal(interner, array_literal))
+        }
+        Literal::Slice(array_literal) => {
+            Literal::Array(remove_interned_in_array_literal(interner, array_literal))
+        }
+        Literal::Bool(_)
+        | Literal::Integer(_, _)
+        | Literal::Str(_)
+        | Literal::RawStr(_, _)
+        | Literal::FmtStr(_)
+        | Literal::Unit => literal,
+    }
+}
+
+fn remove_interned_in_array_literal(
+    interner: &NodeInterner,
+    literal: ArrayLiteral,
+) -> ArrayLiteral {
+    match literal {
+        ArrayLiteral::Standard(expressions) => {
+            ArrayLiteral::Standard(vecmap(expressions, |expr| {
+                remove_interned_in_expression(interner, expr)
+            }))
+        }
+        ArrayLiteral::Repeated { repeated_element, length } => ArrayLiteral::Repeated {
+            repeated_element: Box::new(remove_interned_in_expression(interner, *repeated_element)),
+            length: Box::new(remove_interned_in_expression(interner, *length)),
+        },
+    }
+}
+
+// Returns a new Statement where all Interned statements have been turned into non-interned StatementKind.
+fn remove_interned_in_statement(interner: &NodeInterner, statement: Statement) -> Statement {
+    Statement {
+        kind: remove_interned_in_statement_kind(interner, statement.kind),
+        span: statement.span,
+    }
+}
+
+// Returns a new StatementKind where all Interned statements have been turned into non-interned StatementKind.
+fn remove_interned_in_statement_kind(
+    interner: &NodeInterner,
+    statement: StatementKind,
+) -> StatementKind {
+    match statement {
+        StatementKind::Let(let_statement) => StatementKind::Let(LetStatement {
+            expression: remove_interned_in_expression(interner, let_statement.expression),
+            ..let_statement
+        }),
+        StatementKind::Constrain(constrain) => StatementKind::Constrain(ConstrainStatement(
+            remove_interned_in_expression(interner, constrain.0),
+            constrain.1.map(|expr| remove_interned_in_expression(interner, expr)),
+            constrain.2,
+        )),
+        StatementKind::Expression(expr) => {
+            StatementKind::Expression(remove_interned_in_expression(interner, expr))
+        }
+        StatementKind::Assign(assign) => StatementKind::Assign(AssignStatement {
+            lvalue: assign.lvalue,
+            expression: remove_interned_in_expression(interner, assign.expression),
+        }),
+        StatementKind::For(for_loop) => StatementKind::For(ForLoopStatement {
+            range: match for_loop.range {
+                ForRange::Range(from, to) => ForRange::Range(
+                    remove_interned_in_expression(interner, from),
+                    remove_interned_in_expression(interner, to),
+                ),
+                ForRange::Array(expr) => {
+                    ForRange::Array(remove_interned_in_expression(interner, expr))
+                }
+            },
+            block: remove_interned_in_expression(interner, for_loop.block),
+            ..for_loop
+        }),
+        StatementKind::Comptime(statement) => {
+            StatementKind::Comptime(Box::new(remove_interned_in_statement(interner, *statement)))
+        }
+        StatementKind::Semi(expr) => {
+            StatementKind::Semi(remove_interned_in_expression(interner, expr))
+        }
+        StatementKind::Interned(id) => {
+            let statement = interner.get_statement_kind(id).clone();
+            remove_interned_in_statement_kind(interner, statement)
+        }
+        StatementKind::Break | StatementKind::Continue | StatementKind::Error => statement,
+    }
+}
+
+// Returns a new LValue where all Interned LValues have been turned into LValue.
+fn remove_interned_in_lvalue(interner: &NodeInterner, lvalue: LValue) -> LValue {
+    match lvalue {
+        LValue::Ident(_) => lvalue,
+        LValue::MemberAccess { object, field_name, span } => LValue::MemberAccess {
+            object: Box::new(remove_interned_in_lvalue(interner, *object)),
+            field_name,
+            span,
+        },
+        LValue::Index { array, index, span } => LValue::Index {
+            array: Box::new(remove_interned_in_lvalue(interner, *array)),
+            index: remove_interned_in_expression(interner, index),
+            span,
+        },
+        LValue::Dereference(lvalue, span) => {
+            LValue::Dereference(Box::new(remove_interned_in_lvalue(interner, *lvalue)), span)
+        }
+        LValue::Interned(id, span) => {
+            let lvalue = interner.get_lvalue(id, span);
+            remove_interned_in_lvalue(interner, lvalue)
+        }
+    }
+}
+
 // Returns a new Expression where all Interned and Resolved expressions have been turned into non-interned ExpressionKind.
 fn remove_interned_in_expression(interner: &NodeInterner, expr: Expression) -> Expression {
     Expression { kind: remove_interned_in_expression_kind(interner, expr.kind), span: expr.span }