feat: Sync from noir

.noir-sync-commit

@@ -1 +1 @@
-9c99a97ca8f42bee23cf97ebd724fdc51e647c60
+14adafc965fa9c833e096ec037e086aae67703ad

noir/noir-repo/Cargo.toml

@@ -131,6 +131,7 @@ similar-asserts = "1.5.0"
 tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
+rand = "0.8.5"
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"

noir/noir-repo/acvm-repo/acir_field/src/lib.rs

@@ -2,9 +2,9 @@
 #![warn(unreachable_pub)]
 #![warn(clippy::semicolon_if_nothing_returned)]
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
-mod generic_ark;
 
 mod field_element;
+mod generic_ark;
 
 pub use generic_ark::AcirField;
 

noir/noir-repo/acvm-repo/acvm/Cargo.toml

@@ -16,6 +16,7 @@ repository.workspace = true
 num-bigint.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
+serde.workspace = true
 
 acir.workspace = true
 brillig_vm.workspace = true
@@ -36,7 +37,7 @@ bls12_381 = [
 ]
 
 [dev-dependencies]
-rand = "0.8.5"
+rand.workspace = true
 proptest = "1.2.0"
 paste = "1.0.14"
 ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }

noir/noir-repo/acvm-repo/acvm/src/pwg/brillig.rs

@@ -13,6 +13,7 @@ use acir::{
 };
 use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use brillig_vm::{FailureReason, MemoryValue, VMStatus, VM};
+use serde::{Deserialize, Serialize};
 
 use crate::{pwg::OpcodeNotSolvable, OpcodeResolutionError};
 
@@ -286,7 +287,7 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
 /// where the result of the foreign call has not yet been provided.
 ///
 /// The caller must resolve this opcode externally based upon the information in the request.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct ForeignCallWaitInfo<F> {
     /// An identifier interpreted by the caller process
     pub function: String,

noir/noir-repo/acvm-repo/brillig/src/foreign_call.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 
 /// Single output of a [foreign call][crate::Opcode::ForeignCall].
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
+#[serde(untagged)]
 pub enum ForeignCallParam<F> {
     Single(F),
     Array(Vec<F>),

noir/noir-repo/compiler/integration-tests/package.json

@@ -1,34 +1,34 @@
 {
-    "name": "integration-tests",
-    "license": "(MIT OR Apache-2.0)",
-    "main": "index.js",
-    "private": true,
-    "scripts": {
-        "build": "echo Integration Test build step",
-        "test": "yarn test:browser && yarn test:node",
-        "test:node": "bash ./scripts/setup.sh && hardhat test test/node/prove_and_verify.test.ts && hardhat test test/node/smart_contract_verifier.test.ts && hardhat test test/node/onchain_recursive_verification.test.ts",
-        "test:browser": "web-test-runner",
-        "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
-        "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
-        "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
-    },
-    "dependencies": {
-        "@noir-lang/backend_barretenberg": "workspace:*",
-        "@noir-lang/noir_js": "workspace:*",
-        "@noir-lang/noir_wasm": "workspace:*",
-        "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
-        "@nomicfoundation/hardhat-ethers": "^3.0.0",
-        "@web/dev-server-esbuild": "^0.3.6",
-        "@web/dev-server-import-maps": "^0.2.0",
-        "@web/test-runner": "^0.18.1",
-        "@web/test-runner-playwright": "^0.10.0",
-        "eslint": "^8.57.0",
-        "eslint-plugin-prettier": "^5.1.3",
-        "ethers": "^6.7.1",
-        "hardhat": "^2.17.4",
-        "prettier": "3.2.5",
-        "smol-toml": "^1.1.2",
-        "toml": "^3.0.0",
-        "tslog": "^4.9.2"
-    }
+  "name": "integration-tests",
+  "license": "(MIT OR Apache-2.0)",
+  "main": "index.js",
+  "private": true,
+  "scripts": {
+    "build": "echo Integration Test build step",
+    "test": "yarn test:browser && yarn test:node",
+    "test:node": "bash ./scripts/setup.sh && hardhat test test/node/**/*",
+    "test:browser": "web-test-runner",
+    "test:integration:browser": "web-test-runner test/browser/**/*.test.ts",
+    "test:integration:browser:watch": "web-test-runner test/browser/**/*.test.ts --watch",
+    "lint": "NODE_NO_WARNINGS=1 eslint . --ext .ts --ignore-path ./.eslintignore  --max-warnings 0"
+  },
+  "dependencies": {
+    "@noir-lang/backend_barretenberg": "workspace:*",
+    "@noir-lang/noir_js": "workspace:*",
+    "@noir-lang/noir_wasm": "workspace:*",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@web/dev-server-esbuild": "^0.3.6",
+    "@web/dev-server-import-maps": "^0.2.0",
+    "@web/test-runner": "^0.18.1",
+    "@web/test-runner-playwright": "^0.10.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "ethers": "^6.7.1",
+    "hardhat": "^2.17.4",
+    "prettier": "3.2.5",
+    "smol-toml": "^1.1.2",
+    "toml": "^3.0.0",
+    "tslog": "^4.9.2"
+  }
 }

noir/noir-repo/compiler/integration-tests/test/node/prove_and_verify.test.ts

@@ -28,7 +28,7 @@ it('end-to-end proof creation and verification (outer)', async () => {
   const proof = await backend.generateProof(witness);
 
   // Proof verification
-  const isValid = await backend.verifyProof(proof);
+  const isValid = await prover.verifyProof(proof);
   expect(isValid).to.be.true;
 });
 
@@ -44,7 +44,7 @@ it('end-to-end proof creation and verification (outer) -- Verifier API', async (
   const { witness } = await program.execute(inputs);
 
   // Generate proof
-  // const backend = new Backend(assert_lt_program);
+  const backend = new Backend(assert_lt_program);
   const proof = await backend.generateProof(witness);
 
   const verificationKey = await backend.getVerificationKey();

noir/noir-repo/compiler/noirc_evaluator/src/errors.rs

@@ -43,6 +43,8 @@ pub enum RuntimeError {
     UnconstrainedSliceReturnToConstrained { call_stack: CallStack },
     #[error("All `oracle` methods should be wrapped in an unconstrained fn")]
     UnconstrainedOracleReturnToConstrained { call_stack: CallStack },
+    #[error("Could not resolve some references to the array. All references must be resolved at compile time")]
+    UnknownReference { call_stack: CallStack },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -123,7 +125,8 @@ impl RuntimeError {
             | RuntimeError::NestedSlice { call_stack, .. }
             | RuntimeError::BigIntModulus { call_stack, .. }
             | RuntimeError::UnconstrainedSliceReturnToConstrained { call_stack }
-            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack } => call_stack,
+            | RuntimeError::UnconstrainedOracleReturnToConstrained { call_stack }
+            | RuntimeError::UnknownReference { call_stack } => call_stack,
         }
     }
 }

noir/noir-repo/compiler/noirc_evaluator/src/ssa/acir_gen/mod.rs

@@ -682,7 +682,9 @@ impl<'a> Context<'a> {
                 self.handle_array_operation(instruction_id, dfg)?;
             }
             Instruction::Allocate => {
-                unreachable!("Expected all allocate instructions to be removed before acir_gen")
+                return Err(RuntimeError::UnknownReference {
+                    call_stack: self.acir_context.get_call_stack().clone(),
+                });
             }
             Instruction::Store { .. } => {
                 unreachable!("Expected all store instructions to be removed before acir_gen")
@@ -839,9 +841,10 @@ impl<'a> Context<'a> {
                         self.handle_ssa_call_outputs(result_ids, outputs, dfg)?;
                     }
                     Value::ForeignFunction(_) => {
+                        // TODO: Remove this once elaborator is default frontend. This is now caught by a lint inside the frontend.
                         return Err(RuntimeError::UnconstrainedOracleReturnToConstrained {
                             call_stack: self.acir_context.get_call_stack(),
-                        })
+                        });
                     }
                     _ => unreachable!("expected calling a function but got {function_value:?}"),
                 }
@@ -1306,6 +1309,9 @@ impl<'a> Context<'a> {
                 }
                 Ok(AcirValue::Array(values))
             }
+            Type::Reference(reference_type) => {
+                self.array_get_value(reference_type.as_ref(), block_id, var_index)
+            }
             _ => unreachable!("ICE: Expected an array or numeric but got {ssa_type:?}"),
         }
     }

noir/noir-repo/compiler/noirc_frontend/src/ast/expression.rs

@@ -34,7 +34,7 @@ pub enum ExpressionKind {
     Lambda(Box<Lambda>),
     Parenthesized(Box<Expression>),
     Quote(BlockExpression),
-    Comptime(BlockExpression),
+    Comptime(BlockExpression, Span),
 
     // This variant is only emitted when inlining the result of comptime
     // code. It is used to translate function values back into the AST while
@@ -536,7 +536,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}"),
+            Comptime(block, _) => write!(f, "comptime {block}"),
             Error => write!(f, "Error"),
             Resolved(_) => write!(f, "?Resolved"),
         }

noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -59,7 +59,7 @@ impl<'context> Elaborator<'context> {
             ExpressionKind::Lambda(lambda) => self.elaborate_lambda(*lambda),
             ExpressionKind::Parenthesized(expr) => return self.elaborate_expression(*expr),
             ExpressionKind::Quote(quote) => self.elaborate_quote(quote),
-            ExpressionKind::Comptime(comptime) => {
+            ExpressionKind::Comptime(comptime, _) => {
                 return self.elaborate_comptime_block(comptime, expr.span)
             }
             ExpressionKind::Resolved(id) => return (id, self.interner.id_type(id)),

noir/noir-repo/compiler/noirc_frontend/src/elaborator/lints.rs

@@ -10,7 +10,7 @@ use crate::{
         HirExpression, HirLiteral, NodeInterner, NoirFunction, UnaryOp, UnresolvedTypeData,
         Visibility,
     },
-    node_interner::{DefinitionKind, ExprId},
+    node_interner::{DefinitionKind, ExprId, FuncId},
     Type,
 };
 use acvm::AcirField;
@@ -72,6 +72,40 @@ pub(super) fn low_level_function_outside_stdlib(
     }
 }
 
+/// Oracle definitions (functions with the `#[oracle]` attribute) must be marked as unconstrained.
+pub(super) fn oracle_not_marked_unconstrained(func: &NoirFunction) -> Option<ResolverError> {
+    let is_oracle_function =
+        func.attributes().function.as_ref().map_or(false, |func| func.is_oracle());
+    if is_oracle_function && !func.def.is_unconstrained {
+        Some(ResolverError::OracleMarkedAsConstrained { ident: func.name_ident().clone() })
+    } else {
+        None
+    }
+}
+
+/// Oracle functions may not be called by constrained functions directly.
+///
+/// In order for a constrained function to call an oracle it must first call through an unconstrained function.
+pub(super) fn oracle_called_from_constrained_function(
+    interner: &NodeInterner,
+    called_func: &FuncId,
+    calling_from_constrained_runtime: bool,
+    span: Span,
+) -> Option<ResolverError> {
+    if !calling_from_constrained_runtime {
+        return None;
+    }
+
+    let function_attributes = interner.function_attributes(called_func);
+    let is_oracle_call =
+        function_attributes.function.as_ref().map_or(false, |func| func.is_oracle());
+    if is_oracle_call {
+        Some(ResolverError::UnconstrainedOracleReturnToConstrained { span })
+    } else {
+        None
+    }
+}
+
 /// `pub` is required on return types for entry point functions
 pub(super) fn missing_pub(func: &NoirFunction, is_entry_point: bool) -> Option<ResolverError> {
     if is_entry_point

noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs

@@ -565,6 +565,7 @@ impl<'context> Elaborator<'context> {
         self.run_lint(|elaborator| {
             lints::unnecessary_pub_return(func, elaborator.pub_allowed(func)).map(Into::into)
         });
+        self.run_lint(|_| lints::oracle_not_marked_unconstrained(func).map(Into::into));
         self.run_lint(|elaborator| {
             lints::low_level_function_outside_stdlib(func, elaborator.crate_id).map(Into::into)
         });

noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs

@@ -17,7 +17,7 @@ use crate::{
     },
     hir_def::{
         expr::{
-            HirBinaryOp, HirCallExpression, HirIdent, HirMemberAccess, HirMethodReference,
+            HirBinaryOp, HirCallExpression, HirMemberAccess, HirMethodReference,
             HirPrefixExpression,
         },
         function::{FuncMeta, Parameters},
@@ -1155,6 +1155,19 @@ impl<'context> Elaborator<'context> {
         let is_unconstrained_call = self.is_unconstrained_call(call.func);
         let crossing_runtime_boundary = is_current_func_constrained && is_unconstrained_call;
         if crossing_runtime_boundary {
+            let called_func_id = self
+                .interner
+                .lookup_function_from_expr(&call.func)
+                .expect("Called function should exist");
+            self.run_lint(|elaborator| {
+                lints::oracle_called_from_constrained_function(
+                    elaborator.interner,
+                    &called_func_id,
+                    is_current_func_constrained,
+                    span,
+                )
+                .map(Into::into)
+            });
             let errors = lints::unconstrained_function_args(&args);
             for error in errors {
                 self.push_err(error);
@@ -1173,15 +1186,12 @@ impl<'context> Elaborator<'context> {
     }
 
     fn is_unconstrained_call(&self, expr: ExprId) -> bool {
-        if let HirExpression::Ident(HirIdent { id, .. }, _) = self.interner.expression(&expr) {
-            if let Some(DefinitionKind::Function(func_id)) =
-                self.interner.try_definition(id).map(|def| &def.kind)
-            {
-                let modifiers = self.interner.function_modifiers(func_id);
-                return modifiers.is_unconstrained;
-            }
+        if let Some(func_id) = self.interner.lookup_function_from_expr(&expr) {
+            let modifiers = self.interner.function_modifiers(&func_id);
+            modifiers.is_unconstrained
+        } else {
+            false
         }
-        false
     }
 
     /// Check if the given method type requires a mutable reference to the object type, and check

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

@@ -36,7 +36,7 @@ pub enum InterpreterError {
     CannotInlineMacro { value: Value, location: Location },
     UnquoteFoundDuringEvaluation { location: Location },
 
-    Unimplemented { item: &'static str, location: Location },
+    Unimplemented { item: String, 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