Merge branch 'master' into tf/def-collection-visiblity

* master: (105 commits)
  chore: unbundle `check_array_is_initialized` (#5451)
  feat: Sync from aztec-packages (#5467)
  chore: bump bb to 0.45.1 (#5469)
  feat: prefix operator overload trait dispatch (#5423)
  feat: add CLI argument for debugging comptime blocks (#5192)
  chore: document EmbeddedCurvePoint (#5468)
  feat: lsp rename/find-all-references for struct members (#5443)
  feat(optimization): Deduplicate more instructions (#5457)
  fix: remove compile-time error for invalid indices (#5466)
  feat: lsp rename/find-all-references for local variables (#5439)
  feat: remove duplicated array reads at constant indices (#5445)
  fix: Account for the expected kind when resolving turbofish generics (#5448)
  fix: Fix issue with unresolved results (#5453)
  feat: apply `no_predicates` in stdlib (#5454)
  fix: prevent `no_predicates` from removing predicates in calling function (#5452)
  feat: lsp rename/find-all-references for globals (#5415)
  feat: remove redundant `EnableSideEffects` instructions (#5440)
  fix: Change panic to error in interpreter (#5446)
  feat: Add more slice methods to the stdlib (#5424)
  feat: Unquote multiple items from annotations (#5441)
  ...

.aztec-sync-commit

@@ -1 +1 @@
-12af650f0d27c37dca06bb329bf76a5574534d78
+e44ef7042c87d3c78a14413ad7d54e4ed642ad89

.github/workflows/mirror-external_libs.yml

@@ -0,0 +1,8 @@
+name: Mirror Repositories
+on:
+  workflow_dispatch: {} 
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo Dummy workflow TODO

.github/workflows/publish-nargo.yml

@@ -110,7 +110,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        target: [x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl]
+        target: [x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl, aarch64-unknown-linux-gnu]
     timeout-minutes: 30
 
     steps:

Cargo.toml

@@ -24,6 +24,7 @@ members = [
     "tooling/noirc_abi",
     "tooling/noirc_abi_wasm",
     "tooling/acvm_cli",
+    "tooling/profiler",
     # ACVM
     "acvm-repo/acir_field",
     "acvm-repo/acir",
@@ -36,7 +37,7 @@ members = [
     # Utility crates
     "utils/iter-extended",
 ]
-default-members = ["tooling/nargo_cli", "tooling/acvm_cli"]
+default-members = ["tooling/nargo_cli", "tooling/acvm_cli", "tooling/profiler"]
 resolver = "2"
 
 [workspace.package]
@@ -84,7 +85,7 @@ acvm_cli = { path = "tooling/acvm_cli" }
 # Arkworks
 ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
 ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
-grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
+grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] }
 ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
 ark-std = { version = "^0.4.0", default-features = false }
@@ -143,11 +144,11 @@ similar-asserts = "1.5.0"
 tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
+color-eyre = "0.6.2"
 rand = "0.8.5"
 proptest = "1.2.0"
 proptest-derive = "0.4.0"
 
-
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
 tracing-web = "0.1.3"

acvm-repo/acir/codegen/acir.cpp

@@ -13,8 +13,33 @@ namespace Program {
         static Witness bincodeDeserialize(std::vector<uint8_t>);
     };
 
+    struct ConstantOrWitnessEnum {
+
+        struct Constant {
+            std::string value;
+
+            friend bool operator==(const Constant&, const Constant&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Constant bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct Witness {
+            Program::Witness value;
+
+            friend bool operator==(const Witness&, const Witness&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Witness bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Constant, Witness> value;
+
+        friend bool operator==(const ConstantOrWitnessEnum&, const ConstantOrWitnessEnum&);
+        std::vector<uint8_t> bincodeSerialize() const;
+        static ConstantOrWitnessEnum bincodeDeserialize(std::vector<uint8_t>);
+    };
+
     struct FunctionInput {
-        Program::Witness witness;
+        Program::ConstantOrWitnessEnum input;
         uint32_t num_bits;
 
         friend bool operator==(const FunctionInput&, const FunctionInput&);
@@ -5716,6 +5741,124 @@ Program::Circuit serde::Deserializable<Program::Circuit>::deserialize(Deserializ
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const ConstantOrWitnessEnum &lhs, const ConstantOrWitnessEnum &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ConstantOrWitnessEnum::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ConstantOrWitnessEnum>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ConstantOrWitnessEnum ConstantOrWitnessEnum::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ConstantOrWitnessEnum>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ConstantOrWitnessEnum>::serialize(const Program::ConstantOrWitnessEnum &obj, Serializer &serializer) {
+    serializer.increase_container_depth();
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+    serializer.decrease_container_depth();
+}
+
+template <>
+template <typename Deserializer>
+Program::ConstantOrWitnessEnum serde::Deserializable<Program::ConstantOrWitnessEnum>::deserialize(Deserializer &deserializer) {
+    deserializer.increase_container_depth();
+    Program::ConstantOrWitnessEnum obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    deserializer.decrease_container_depth();
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const ConstantOrWitnessEnum::Constant &lhs, const ConstantOrWitnessEnum::Constant &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ConstantOrWitnessEnum::Constant::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ConstantOrWitnessEnum::Constant>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ConstantOrWitnessEnum::Constant ConstantOrWitnessEnum::Constant::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ConstantOrWitnessEnum::Constant>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ConstantOrWitnessEnum::Constant>::serialize(const Program::ConstantOrWitnessEnum::Constant &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::ConstantOrWitnessEnum::Constant serde::Deserializable<Program::ConstantOrWitnessEnum::Constant>::deserialize(Deserializer &deserializer) {
+    Program::ConstantOrWitnessEnum::Constant obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
+namespace Program {
+
+    inline bool operator==(const ConstantOrWitnessEnum::Witness &lhs, const ConstantOrWitnessEnum::Witness &rhs) {
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> ConstantOrWitnessEnum::Witness::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<ConstantOrWitnessEnum::Witness>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline ConstantOrWitnessEnum::Witness ConstantOrWitnessEnum::Witness::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<ConstantOrWitnessEnum::Witness>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::ConstantOrWitnessEnum::Witness>::serialize(const Program::ConstantOrWitnessEnum::Witness &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::ConstantOrWitnessEnum::Witness serde::Deserializable<Program::ConstantOrWitnessEnum::Witness>::deserialize(Deserializer &deserializer) {
+    Program::ConstantOrWitnessEnum::Witness obj;
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const Directive &lhs, const Directive &rhs) {
@@ -6086,7 +6229,7 @@ Program::ExpressionWidth::Bounded serde::Deserializable<Program::ExpressionWidth
 namespace Program {
 
     inline bool operator==(const FunctionInput &lhs, const FunctionInput &rhs) {
-        if (!(lhs.witness == rhs.witness)) { return false; }
+        if (!(lhs.input == rhs.input)) { return false; }
         if (!(lhs.num_bits == rhs.num_bits)) { return false; }
         return true;
     }
@@ -6112,7 +6255,7 @@ template <>
 template <typename Serializer>
 void serde::Serializable<Program::FunctionInput>::serialize(const Program::FunctionInput &obj, Serializer &serializer) {
     serializer.increase_container_depth();
-    serde::Serializable<decltype(obj.witness)>::serialize(obj.witness, serializer);
+    serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.num_bits)>::serialize(obj.num_bits, serializer);
     serializer.decrease_container_depth();
 }
@@ -6122,7 +6265,7 @@ template <typename Deserializer>
 Program::FunctionInput serde::Deserializable<Program::FunctionInput>::deserialize(Deserializer &deserializer) {
     deserializer.increase_container_depth();
     Program::FunctionInput obj;
-    obj.witness = serde::Deserializable<decltype(obj.witness)>::deserialize(deserializer);
+    obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.num_bits = serde::Deserializable<decltype(obj.num_bits)>::deserialize(deserializer);
     deserializer.decrease_container_depth();
     return obj;