chore: Noir version for Pedersen commitment and hash (noir-lang/noir#…

…5431)

chore: add benchmark for ecdsa (noir-lang/noir#5113)
feat(nargo): Default expression width field in `Nargo.toml` (noir-lang/noir#5505)
chore: bump hardhat version to `2.22.6` (noir-lang/noir#5514)
chore: added regression test for check_for_underconstrained_values resolve bug (noir-lang/noir#5490)
feat: add debug codelens action (noir-lang/noir#5474)
chore(ci): remove bad colon in yaml file (noir-lang/noir#5520)
chore(ci): add workflow to run `nargo check` on external repos (noir-lang/noir#5355)
feat: add support for usage of `super` in import paths (noir-lang/noir#5502)
feat: Allow comptime attributes on traits & functions (noir-lang/noir#5496)
feat: skip reading values immediately after it being written into an array (noir-lang/noir#5449)
fix: Don't type error when calling certain trait impls in the interpreter (noir-lang/noir#5471)
feat: LSP hover (noir-lang/noir#5491)
chore: update typo PR script (noir-lang/noir#5488)
feat: Handle ACIR calls in the debugger (noir-lang/noir#5051)
feat: Add unquote function (noir-lang/noir#5497)
feat: Allow arguments to attribute functions (noir-lang/noir#5494)

.noir-sync-commit

@@ -1 +1 @@
-b59a29e5b246121a4d81e4894a4b10f5df4dd5cf
+029584b7e936abf6eb8ebce043585725b3b93e72

noir/noir-repo/.github/workflows/test-js-packages.yml

@@ -509,6 +509,59 @@ jobs:
         working-directory: ./examples/codegen_verifier
         run: ./test.sh
 
+  external-repo-checks:
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        project:
+         - { repo: AztecProtocol/aztec-nr, path: ./ }
+         - { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-contracts }
+         # Disabled as aztec-packages requires a setup-step in order to generate a `Nargo.toml`
+         #- { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-protocol-circuits }
+         - { repo: zac-williamson/noir-edwards, path: ./, ref: 0016ce82cd58b6ebb0c43c271725590bcff4e755  }
+        # TODO: Enable these once they're passing against master again.
+        #  - { repo: zac-williamson/noir-bignum, path: ./, ref: 030c2acce1e6b97c44a3bbbf3429ed96f20d72d3  }
+        #  - { repo: vlayer-xyz/monorepo, path: ./, ref: ee46af88c025863872234eb05d890e1e447907cb }
+        #  - { repo: hashcloak/noir-bigint, path: ./, ref: 940ddba3a5201b508e7b37a2ef643551afcf5ed8 }
+
+    name: Check external repo - ${{ matrix.project.repo }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.project.repo }}
+          path: test-repo
+          ref: ${{ matrix.project.ref }}
+
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+      
+      - name: Remove requirements on compiler version
+        working-directory: ./test-repo
+        run: |
+          # Github actions seems to not expand "**" in globs by default.
+          shopt -s globstar
+          sed -i '/^compiler_version/d' ./**/Nargo.toml
+
+      - name: Run nargo check
+        working-directory: ./test-repo/${{ matrix.project.path }}
+        run: nargo check
+
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:

noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs

@@ -277,7 +277,8 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             | BlackBoxFuncCall::BigIntDiv { .. }
             | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
             BlackBoxFuncCall::MultiScalarMul { points, scalars, .. } => {
-                let mut inputs: Vec<FunctionInput<F>> = Vec::with_capacity(points.len() * 2);
+                let mut inputs: Vec<FunctionInput<F>> =
+                    Vec::with_capacity(points.len() + scalars.len());
                 inputs.extend(points.iter().copied());
                 inputs.extend(scalars.iter().copied());
                 inputs

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

@@ -25,7 +25,7 @@
         "eslint": "^8.57.0",
         "eslint-plugin-prettier": "^5.1.3",
         "ethers": "^6.7.1",
-        "hardhat": "^2.17.4",
+        "hardhat": "^2.22.6",
         "prettier": "3.2.5",
         "smol-toml": "^1.1.2",
         "toml": "^3.0.0",

noir/noir-repo/compiler/noirc_driver/src/lib.rs

@@ -52,9 +52,9 @@ pub const NOIR_ARTIFACT_VERSION_STRING: &str =
 
 #[derive(Args, Clone, Debug, Default)]
 pub struct CompileOptions {
-    /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width, default_value = "4")]
-    pub expression_width: ExpressionWidth,
+    /// Specify the backend expression width that should be targeted
+    #[arg(long, value_parser = parse_expression_width)]
+    pub expression_width: Option<ExpressionWidth>,
 
     /// Force a full recompilation.
     #[arg(long = "force")]
@@ -113,7 +113,7 @@ pub struct CompileOptions {
     pub show_artifact_paths: bool,
 }
 
-fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
+pub fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
     use std::io::{Error, ErrorKind};
     let width = input
         .parse::<usize>()

noir/noir-repo/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs

@@ -752,27 +752,24 @@ impl<'f> Context<'f> {
                         Instruction::Call { func, arguments }
                     }
                     Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul)) => {
-                        let mut array_with_predicate = im::Vector::new();
-                        let array_typ;
-                        if let Value::Array { array, typ } =
-                            &self.inserter.function.dfg[arguments[0]]
-                        {
-                            array_typ = typ.clone();
-                            for (i, value) in array.clone().iter().enumerate() {
-                                if i % 3 == 2 {
-                                    array_with_predicate.push_back(self.var_or_one(
-                                        *value,
-                                        condition,
-                                        call_stack.clone(),
-                                    ));
-                                } else {
-                                    array_with_predicate.push_back(*value);
-                                }
-                            }
+                        let points_array_idx = if matches!(
+                            self.inserter.function.dfg[arguments[0]],
+                            Value::Array { .. }
+                        ) {
+                            0
                         } else {
-                            unreachable!();
-                        }
-                        arguments[0] =
+                            // if the first argument is not an array, we assume it is a slice
+                            // which means the array is the second argument
+                            1
+                        };
+                        let (array_with_predicate, array_typ) = self
+                            .apply_predicate_to_msm_argument(
+                                arguments[points_array_idx],
+                                condition,
+                                call_stack.clone(),
+                            );
+
+                        arguments[points_array_idx] =
                             self.inserter.function.dfg.make_array(array_with_predicate, array_typ);
                         Instruction::Call { func, arguments }
                     }
@@ -785,6 +782,40 @@ impl<'f> Context<'f> {
         }
     }
 
+    /// When a MSM is done under a predicate, we need to apply the predicate
+    /// to the is_infinity property of the input points in order to ensure
+    /// that the points will be on the curve no matter what.
+    fn apply_predicate_to_msm_argument(
+        &mut self,
+        argument: ValueId,
+        predicate: ValueId,
+        call_stack: CallStack,
+    ) -> (im::Vector<ValueId>, Type) {
+        let array_typ;
+        let mut array_with_predicate = im::Vector::new();
+        if let Value::Array { array, typ } = &self.inserter.function.dfg[argument] {
+            array_typ = typ.clone();
+            for (i, value) in array.clone().iter().enumerate() {
+                if i % 3 == 2 {
+                    array_with_predicate.push_back(self.var_or_one(
+                        *value,
+                        predicate,
+                        call_stack.clone(),
+                    ));
+                } else {
+                    array_with_predicate.push_back(*value);
+                }
+            }
+        } else {
+            unreachable!(
+                "Expected an array, got {}",
+                &self.inserter.function.dfg.type_of_value(argument)
+            );
+        };
+
+        (array_with_predicate, array_typ)
+    }
+
     // Computes: if condition { var } else { 1 }
     fn var_or_one(&mut self, var: ValueId, condition: ValueId, call_stack: CallStack) -> ValueId {
         let field = self.insert_instruction(

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

@@ -299,6 +299,7 @@ pub enum PathKind {
     Crate,
     Dep,
     Plain,
+    Super,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -748,6 +749,7 @@ impl Display for PathKind {
         match self {
             PathKind::Crate => write!(f, "crate"),
             PathKind::Dep => write!(f, "dep"),
+            PathKind::Super => write!(f, "super"),
             PathKind::Plain => write!(f, "plain"),
         }
     }

noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs

@@ -732,11 +732,7 @@ impl<'a> ModCollector<'a> {
 
             context.def_interner.add_module_attributes(
                 mod_id,
-                ModuleAttributes {
-                    name: mod_name.0.contents.clone(),
-                    location: mod_location,
-                    parent: self.module_id,
-                },
+                ModuleAttributes { name: mod_name.0.contents.clone(), location: mod_location },
             );
         }
 

noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/import.rs

@@ -41,6 +41,8 @@ pub enum PathResolutionError {
     Unresolved(Ident),
     #[error("{0} is private and not visible from the current module")]
     Private(Ident),
+    #[error("There is no super module")]
+    NoSuper(Span),
 }
 
 #[derive(Debug)]
@@ -73,6 +75,9 @@ impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
                 format!("{ident} is private"),
                 ident.span(),
             ),
+            PathResolutionError::NoSuper(span) => {
+                CustomDiagnostic::simple_error(error.to_string(), String::new(), *span)
+            }
         }
     }
 }
@@ -187,6 +192,25 @@ fn resolve_path_to_ns(
             path_references,
             importing_crate,
         ),
+
+        crate::ast::PathKind::Super => {
+            if let Some(parent_module_id) =
+                def_maps[&crate_id].modules[import_directive.module_id.0].parent
+            {
+                resolve_name_in_module(
+                    crate_id,
+                    importing_crate,
+                    import_path,
+                    parent_module_id,
+                    def_maps,
+                    path_references,
+                )
+            } else {
+                let span_start = import_directive.path.span().start();
+                let span = Span::from(span_start..span_start + 5); // 5 == "super".len()
+                Err(PathResolutionError::NoSuper(span))
+            }
+        }
     }
 }
 

noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs

@@ -48,7 +48,6 @@ const IMPL_SEARCH_RECURSION_LIMIT: u32 = 10;
 pub struct ModuleAttributes {
     pub name: String,
     pub location: Location,
-    pub parent: LocalModuleId,
 }
 
 type StructAttributes = Vec<SecondaryAttribute>;

noir/noir-repo/compiler/noirc_frontend/src/parser/parser/path.rs

@@ -17,6 +17,7 @@ pub(super) fn path() -> impl NoirParser<Path> {
     choice((
         path_kind(Keyword::Crate, PathKind::Crate),
         path_kind(Keyword::Dep, PathKind::Dep),
+        path_kind(Keyword::Super, PathKind::Super),
         idents().map_with_span(make_path(PathKind::Plain)),
     ))
 }
@@ -64,6 +65,7 @@ mod test {
             ("std", PathKind::Plain),
             ("hash::collections", PathKind::Plain),
             ("crate::std::hash", PathKind::Crate),
+            ("super::foo", PathKind::Super),
         ];
 
         for (src, expected_path_kind) in cases {