[1 changes] feat: add comptime support for modulus_* compiler built…

…ins (noir-lang/noir#5530)

chore: Remove unknown annotation warning (noir-lang/noir#5531)
feat: Add TraitConstraint type (noir-lang/noir#5499)
fix: Error on empty function bodies (noir-lang/noir#5519)
feat: LSP inlay hints for let and global (noir-lang/noir#5510)
chore: Remove dbg on find_func_with_name (noir-lang/noir#5526)
chore: Remove the remainder of legacy code (noir-lang/noir#5525)
chore: Remove `--use-legacy` and resolution code (noir-lang/noir#5248)
chore: switch to Noir Keccak implementation with variable size support (noir-lang/noir#5508)
chore: standardize experimental feature disclaimer across documentation (noir-lang/noir#5367)

.noir-sync-commit

@@ -1 +1 @@
-bb6913ac53620fabd73e24ca1a2b1369225903ec
+5bbce7977f72b07336bc8ef09f6acff687f1644a

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/mod.rs

@@ -360,7 +360,7 @@ mod tests {
     use std::collections::BTreeSet;
 
     use super::{
-        opcodes::{BlackBoxFuncCall, ConstantOrWitnessEnum, FunctionInput},
+        opcodes::{BlackBoxFuncCall, FunctionInput},
         Circuit, Compression, Opcode, PublicInputs,
     };
     use crate::{

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
@@ -520,7 +521,7 @@ mod tests {
     use crate::{circuit::Opcode, native_types::Witness};
     use acir_field::{AcirField, FieldElement};
 
-    use super::{BlackBoxFuncCall, ConstantOrWitnessEnum, FunctionInput};
+    use super::{BlackBoxFuncCall, FunctionInput};
 
     fn keccakf1600_opcode<F: AcirField>() -> Opcode<F> {
         let inputs: Box<[FunctionInput<F>; 25]> =

noir/noir-repo/acvm-repo/acir/tests/test_program_serialization.rs

@@ -14,7 +14,7 @@ use std::collections::BTreeSet;
 use acir::{
     circuit::{
         brillig::{BrilligBytecode, BrilligInputs, BrilligOutputs},
-        opcodes::{BlackBoxFuncCall, BlockId, ConstantOrWitnessEnum, FunctionInput, MemOp},
+        opcodes::{BlackBoxFuncCall, BlockId, FunctionInput, MemOp},
         Circuit, Opcode, Program, PublicInputs,
     },
     native_types::{Expression, Witness},

noir/noir-repo/acvm-repo/acvm/src/compiler/optimizers/redundant_range.rs

@@ -150,7 +150,7 @@ mod tests {
     use crate::compiler::optimizers::redundant_range::RangeOptimizer;
     use acir::{
         circuit::{
-            opcodes::{BlackBoxFuncCall, ConstantOrWitnessEnum, FunctionInput},
+            opcodes::{BlackBoxFuncCall, FunctionInput},
             Circuit, ExpressionWidth, Opcode, PublicInputs,
         },
         native_types::{Expression, Witness},

noir/noir-repo/acvm-repo/acvm_js/build.sh

@@ -25,7 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-#require_command wasm-opt
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')

noir/noir-repo/acvm-repo/blackbox_solver/src/bigint.rs

@@ -18,7 +18,7 @@ pub struct BigIntSolver {
 }
 
 impl BigIntSolver {
-    pub(crate) fn get_bigint(
+    pub fn get_bigint(
         &self,
         id: u32,
         func: BlackBoxFunc,
@@ -32,7 +32,7 @@ impl BigIntSolver {
             .cloned()
     }
 
-    pub(crate) fn get_modulus(
+    pub fn get_modulus(
         &self,
         id: u32,
         func: BlackBoxFunc,

noir/noir-repo/acvm-repo/brillig_vm/src/black_box.rs

@@ -421,6 +421,14 @@ impl BrilligBigintSolver {
         rhs: u32,
         func: BlackBoxFunc,
     ) -> Result<u32, BlackBoxResolutionError> {
+        let modulus_lhs = self.bigint_solver.get_modulus(lhs, func)?;
+        let modulus_rhs = self.bigint_solver.get_modulus(rhs, func)?;
+        if modulus_lhs != modulus_rhs {
+            return Err(BlackBoxResolutionError::Failed(
+                func,
+                "moduli should be identical in BigInt operation".to_string(),
+            ));
+        }
         let id = self.create_bigint_id();
         self.bigint_solver.bigint_op(lhs, rhs, id, func)?;
         Ok(id)

noir/noir-repo/aztec_macros/src/transforms/note_interface.rs

@@ -73,6 +73,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 generics: vec![],
                 methods: vec![],
                 where_clause: vec![],
+                is_comptime: false,
             };
             module.impls.push(default_impl.clone());
             module.impls.last_mut().unwrap()

noir/noir-repo/aztec_macros/src/transforms/storage.rs

@@ -248,6 +248,7 @@ pub fn generate_storage_implementation(
         methods: vec![(init, Span::default())],
 
         where_clause: vec![],
+        is_comptime: false,
     };
     module.impls.push(storage_impl);
 

noir/noir-repo/aztec_macros/src/utils/hir_utils.rs

@@ -2,15 +2,15 @@ use acvm::acir::AcirField;
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast;
+use noirc_frontend::elaborator::Elaborator;
+use noirc_frontend::hir::def_collector::dc_crate::{
+    CollectedItems, UnresolvedFunctions, UnresolvedGlobal,
+};
 use noirc_frontend::macros_api::{HirExpression, HirLiteral};
 use noirc_frontend::node_interner::{NodeInterner, TraitImplKind};
 use noirc_frontend::{
     graph::CrateId,
-    hir::{
-        def_map::{LocalModuleId, ModuleId},
-        resolution::{path_resolver::StandardPathResolver, resolver::Resolver},
-        type_check::type_check_func,
-    },
+    hir::def_map::{LocalModuleId, ModuleId},
     macros_api::{FileId, HirContext, MacroError, ModuleDefId, StructId},
     node_interner::{FuncId, TraitId},
     Shared, StructType, Type,
@@ -190,24 +190,17 @@ pub fn inject_fn(
             span: None,
         })?;
 
-    let def_maps = &mut context.def_maps;
-
-    let path_resolver =
-        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
-
-    let resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
-
-    let (hir_func, meta, _) = resolver.resolve_function(func, func_id);
+    let mut items = CollectedItems::default();
+    let functions = vec![(module_id, func_id, func)];
+    let trait_id = None;
+    items.functions.push(UnresolvedFunctions { file_id, functions, trait_id, self_type: None });
 
-    context.def_interner.push_fn_meta(meta, func_id);
-    context.def_interner.update_fn(func_id, hir_func);
-
-    let errors = type_check_func(&mut context.def_interner, func_id);
+    let errors = Elaborator::elaborate(context, *crate_id, items, None);
 
     if !errors.is_empty() {
         return Err(MacroError {
             primary_message: "Failed to type check autogenerated function".to_owned(),
-            secondary_message: Some(errors.iter().map(|err| err.to_string()).collect::<String>()),
+            secondary_message: Some(errors.iter().map(|err| err.0.to_string()).collect::<String>()),
             span: None,
         });
     }
@@ -243,17 +236,10 @@ pub fn inject_global(
             )
         });
 
-    let def_maps = &mut context.def_maps;
-
-    let path_resolver =
-        StandardPathResolver::new(ModuleId { local_id: module_id, krate: *crate_id });
-
-    let mut resolver = Resolver::new(&mut context.def_interner, &path_resolver, def_maps, file_id);
-
-    let hir_stmt = resolver.resolve_global_let(global, global_id);
+    let mut items = CollectedItems::default();
+    items.globals.push(UnresolvedGlobal { file_id, module_id, global_id, stmt_def: global });
 
-    let statement_id = context.def_interner.get_global(global_id).let_statement;
-    context.def_interner.replace_statement(statement_id, hir_stmt);
+    let _errors = Elaborator::elaborate(context, *crate_id, items, None);
 }
 
 pub fn fully_qualified_note_path(context: &HirContext, note_id: StructId) -> Option<String> {

noir/noir-repo/compiler/fm/Cargo.toml

@@ -10,6 +10,7 @@ license.workspace = true
 
 [dependencies]
 codespan-reporting.workspace = true
+iter-extended.workspace = true
 serde.workspace = true
 
 [dev-dependencies]

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

@@ -7,6 +7,7 @@ mod file_map;
 
 pub use file_map::{File, FileId, FileMap, PathString};
 
+use iter_extended::vecmap;
 // Re-export for the lsp
 pub use codespan_reporting::files as codespan_files;
 
@@ -103,6 +104,26 @@ impl FileManager {
     pub fn name_to_id(&self, file_name: PathBuf) -> Option<FileId> {
         self.file_map.get_file_id(&PathString::from_path(file_name))
     }
+
+    /// Find a file by its path suffix, e.g. "src/main.nr" is a suffix of
+    /// "some_dir/package_name/src/main.nr"`
+    pub fn find_by_path_suffix(&self, suffix: &str) -> Result<Option<FileId>, Vec<PathBuf>> {
+        let suffix_path: Vec<_> = Path::new(suffix).components().rev().collect();
+        let results: Vec<_> = self
+            .path_to_id
+            .iter()
+            .filter(|(path, _id)| {
+                path.components().rev().zip(suffix_path.iter()).all(|(x, y)| &x == y)
+            })
+            .collect();
+        if results.is_empty() {
+            Ok(None)
+        } else if results.len() == 1 {
+            Ok(Some(*results[0].1))
+        } else {
+            Err(vecmap(results, |(path, _id)| path.clone()))
+        }
+    }
 }
 
 pub trait NormalizePath {

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")]
@@ -99,16 +99,17 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub force_brillig: bool,
 
-    /// Use the deprecated name resolution & type checking passes instead of the elaborator
-    #[arg(long, hide = true)]
-    pub use_legacy: bool,
+    /// Enable printing results of comptime evaluation: provide a path suffix
+    /// for the module to debug, e.g. "package_name/src/main.nr"
+    #[arg(long)]
+    pub debug_comptime_in_file: Option<String>,
 
     /// Outputs the paths to any modified artifacts
     #[arg(long, hide = true)]
     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>()
@@ -257,13 +258,13 @@ pub fn check_crate(
     crate_id: CrateId,
     deny_warnings: bool,
     disable_macros: bool,
-    use_legacy: bool,
+    debug_comptime_in_file: Option<&str>,
 ) -> CompilationResult<()> {
     let macros: &[&dyn MacroProcessor] =
         if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
-    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_legacy, macros);
+    let diagnostics = CrateDefMap::collect_defs(crate_id, context, debug_comptime_in_file, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -300,7 +301,7 @@ pub fn compile_main(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_legacy,
+        options.debug_comptime_in_file.as_deref(),
     )?;
 
     let main = context.get_main_function(&crate_id).ok_or_else(|| {
@@ -341,7 +342,7 @@ pub fn compile_contract(
         crate_id,
         options.deny_warnings,
         options.disable_macros,
-        options.use_legacy,
+        options.debug_comptime_in_file.as_deref(),
     )?;
 
     // TODO: We probably want to error if contracts is empty

noir/noir-repo/compiler/noirc_driver/tests/stdlib_warnings.rs

@@ -25,7 +25,7 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let root_crate_id = prepare_crate(&mut context, file_name);
 
     let ((), warnings) =
-        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false)?;
+        noirc_driver::check_crate(&mut context, root_crate_id, false, false, None)?;
 
     assert_eq!(warnings, Vec::new(), "stdlib is producing {} warnings", warnings.len());
 

noir/noir-repo/compiler/noirc_errors/src/position.rs

@@ -90,6 +90,10 @@ impl Span {
         self.start() <= other.start() && self.end() >= other.end()
     }
 
+    pub fn intersects(&self, other: &Span) -> bool {
+        self.end() > other.start() && self.start() < other.end()
+    }
+
     pub fn is_smaller(&self, other: &Span) -> bool {
         let self_distance = self.end() - self.start();
         let other_distance = other.end() - other.start();