[1 changes] feat: mod.nr entrypoint (noir-lang/noir#5039)

feat!: error on too large integer value (noir-lang/noir#5371)
fix: Runtime brillig bigint id assignment (noir-lang/noir#5369)
feat!: rename struct-specific TypeDefinition -> StructDefinition (noir-lang/noir#5356)

.noir-sync-commit

@@ -1 +1 @@
-f2f8ecc833d4725d0829f9c339389c90d1a4fbcd
+076fe0a11869f6975d214c5b9a5ed1e8f7cdbded

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/brillig_vm/src/black_box.rs

@@ -42,7 +42,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
     op: &BlackBoxOp,
     solver: &Solver,
     memory: &mut Memory<F>,
-    bigint_solver: &mut BigIntSolver,
+    bigint_solver: &mut BrilligBigintSolver,
 ) -> Result<(), BlackBoxResolutionError> {
     match op {
         BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => {
@@ -270,38 +270,44 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
         BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
-            let output = memory.read(*output).try_into().unwrap();
-            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntAdd)?;
+
+            let new_id = bigint_solver.bigint_op(lhs, rhs, BlackBoxFunc::BigIntAdd)?;
+            memory.write(*output, new_id.into());
             Ok(())
         }
         BlackBoxOp::BigIntSub { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
-            let output = memory.read(*output).try_into().unwrap();
-            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntSub)?;
+
+            let new_id = bigint_solver.bigint_op(lhs, rhs, BlackBoxFunc::BigIntSub)?;
+            memory.write(*output, new_id.into());
             Ok(())
         }
         BlackBoxOp::BigIntMul { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
-            let output = memory.read(*output).try_into().unwrap();
-            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntMul)?;
+
+            let new_id = bigint_solver.bigint_op(lhs, rhs, BlackBoxFunc::BigIntMul)?;
+            memory.write(*output, new_id.into());
             Ok(())
         }
         BlackBoxOp::BigIntDiv { lhs, rhs, output } => {
             let lhs = memory.read(*lhs).try_into().unwrap();
             let rhs = memory.read(*rhs).try_into().unwrap();
-            let output = memory.read(*output).try_into().unwrap();
-            bigint_solver.bigint_op(lhs, rhs, output, BlackBoxFunc::BigIntDiv)?;
+
+            let new_id = bigint_solver.bigint_op(lhs, rhs, BlackBoxFunc::BigIntDiv)?;
+            memory.write(*output, new_id.into());
             Ok(())
         }
         BlackBoxOp::BigIntFromLeBytes { inputs, modulus, output } => {
             let input = read_heap_vector(memory, inputs);
             let input: Vec<u8> = input.iter().map(|x| x.try_into().unwrap()).collect();
             let modulus = read_heap_vector(memory, modulus);
             let modulus: Vec<u8> = modulus.iter().map(|x| x.try_into().unwrap()).collect();
-            let output = memory.read(*output).try_into().unwrap();
-            bigint_solver.bigint_from_bytes(&input, &modulus, output)?;
+
+            let new_id = bigint_solver.bigint_from_bytes(&input, &modulus)?;
+            memory.write(*output, new_id.into());
+
             Ok(())
         }
         BlackBoxOp::BigIntToLeBytes { input, output } => {
@@ -381,6 +387,46 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
     }
 }
 
+/// Wrapper over the generic bigint solver to automatically assign bigint ids in brillig
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub(crate) struct BrilligBigintSolver {
+    bigint_solver: BigIntSolver,
+    last_id: u32,
+}
+
+impl BrilligBigintSolver {
+    pub(crate) fn create_bigint_id(&mut self) -> u32 {
+        let output = self.last_id;
+        self.last_id += 1;
+        output
+    }
+
+    pub(crate) fn bigint_from_bytes(
+        &mut self,
+        inputs: &[u8],
+        modulus: &[u8],
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let id = self.create_bigint_id();
+        self.bigint_solver.bigint_from_bytes(inputs, modulus, id)?;
+        Ok(id)
+    }
+
+    pub(crate) fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
+        self.bigint_solver.bigint_to_bytes(input)
+    }
+
+    pub(crate) fn bigint_op(
+        &mut self,
+        lhs: u32,
+        rhs: u32,
+        func: BlackBoxFunc,
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let id = self.create_bigint_id();
+        self.bigint_solver.bigint_op(lhs, rhs, id, func)?;
+        Ok(id)
+    }
+}
+
 fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
     match op {
         BlackBoxOp::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt,
@@ -414,10 +460,10 @@ mod test {
         brillig::{BlackBoxOp, MemoryAddress},
         FieldElement,
     };
-    use acvm_blackbox_solver::{BigIntSolver, StubbedBlackBoxSolver};
+    use acvm_blackbox_solver::StubbedBlackBoxSolver;
 
     use crate::{
-        black_box::{evaluate_black_box, to_u8_vec, to_value_vec},
+        black_box::{evaluate_black_box, to_u8_vec, to_value_vec, BrilligBigintSolver},
         HeapArray, HeapVector, Memory,
     };
 
@@ -439,8 +485,13 @@ mod test {
             output: HeapArray { pointer: 2.into(), size: 32 },
         };
 
-        evaluate_black_box(&op, &StubbedBlackBoxSolver, &mut memory, &mut BigIntSolver::default())
-            .unwrap();
+        evaluate_black_box(
+            &op,
+            &StubbedBlackBoxSolver,
+            &mut memory,
+            &mut BrilligBigintSolver::default(),
+        )
+        .unwrap();
 
         let result = memory.read_slice(MemoryAddress(result_pointer), 32);
 

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

@@ -16,9 +16,9 @@ use acir::brillig::{
     HeapVector, MemoryAddress, Opcode, ValueOrArray,
 };
 use acir::AcirField;
-use acvm_blackbox_solver::{BigIntSolver, BlackBoxFunctionSolver};
+use acvm_blackbox_solver::BlackBoxFunctionSolver;
 use arithmetic::{evaluate_binary_field_op, evaluate_binary_int_op, BrilligArithmeticError};
-use black_box::evaluate_black_box;
+use black_box::{evaluate_black_box, BrilligBigintSolver};
 use num_bigint::BigUint;
 
 // Re-export `brillig`.
@@ -88,7 +88,7 @@ pub struct VM<'a, F, B: BlackBoxFunctionSolver<F>> {
     /// The solver for blackbox functions
     black_box_solver: &'a B,
     // The solver for big integers
-    bigint_solver: BigIntSolver,
+    bigint_solver: BrilligBigintSolver,
 }
 
 impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {

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

@@ -72,6 +72,7 @@ pub fn generate_note_interface_impl(module: &mut SortedModule) -> Result<(), Azt
                 type_span: note_struct.name.span(),
                 generics: vec![],
                 methods: vec![],
+                where_clause: vec![],
             };
             module.impls.push(default_impl.clone());
             module.impls.last_mut().unwrap()
@@ -562,8 +563,7 @@ fn generate_note_properties_struct_source(
         .filter_map(|(field_name, _)| {
             if field_name != note_header_field_name {
                 Some(format!(
-                    "{}: dep::aztec::note::note_getter_options::PropertySelector",
-                    field_name
+                    "{field_name}: dep::aztec::note::note_getter_options::PropertySelector"
                 ))
             } else {
                 None
@@ -670,8 +670,7 @@ fn generate_note_deserialize_content_source(
                 }
             } else {
                 format!(
-                    "{}: dep::aztec::note::note_header::NoteHeader::empty()",
-                    note_header_field_name
+                    "{note_header_field_name}: dep::aztec::note::note_header::NoteHeader::empty()"
                 )
             }
         })

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

@@ -91,7 +91,7 @@ pub fn inject_context_in_storage(module: &mut SortedModule) -> Result<(), AztecM
             r#struct.attributes.iter().any(|attr| is_custom_attribute(attr, "aztec(storage)"))
         })
         .unwrap();
-    storage_struct.generics.push(ident("Context"));
+    storage_struct.generics.push(ident("Context").into());
     storage_struct
         .fields
         .iter_mut()
@@ -243,9 +243,11 @@ pub fn generate_storage_implementation(
             span: Some(Span::default()),
         },
         type_span: Span::default(),
-        generics: vec![generic_context_ident],
+        generics: vec![generic_context_ident.into()],
 
         methods: vec![(init, Span::default())],
+
+        where_clause: vec![],
     };
     module.impls.push(storage_impl);
 

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

@@ -13,5 +13,4 @@ codespan-reporting.workspace = true
 serde.workspace = true
 
 [dev-dependencies]
-tempfile.workspace = true
 iter-extended.workspace = true

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

@@ -185,24 +185,17 @@ mod path_normalization {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempfile::{tempdir, TempDir};
 
-    // Returns the absolute path to the file
-    fn create_dummy_file(dir: &TempDir, file_name: &Path) -> PathBuf {
-        let file_path = dir.path().join(file_name);
-        let _file = std::fs::File::create(&file_path).unwrap();
-        file_path
+    fn add_file(fm: &mut FileManager, file_name: &Path) -> FileId {
+        fm.add_file_with_source(file_name, "fn foo() {}".to_string()).unwrap()
     }
 
     #[test]
     fn path_resolve_file_module_other_ext() {
-        let dir = tempdir().unwrap();
-        let file_name = Path::new("foo.nr");
-        create_dummy_file(&dir, file_name);
+        let dir = PathBuf::new();
+        let mut fm = FileManager::new(&dir);
 
-        let mut fm = FileManager::new(dir.path());
-
-        let file_id = fm.add_file_with_source(file_name, "fn foo() {}".to_string()).unwrap();
+        let file_id = add_file(&mut fm, &dir.join("foo.nr"));
 
         assert!(fm.path(file_id).unwrap().ends_with("foo.nr"));
     }
@@ -213,23 +206,19 @@ mod tests {
     /// they should both resolve to ../foo.nr
     #[test]
     fn path_resolve_modules_with_different_paths_as_same_file() {
-        let dir = tempdir().unwrap();
-        let sub_dir = TempDir::new_in(&dir).unwrap();
-        let sub_sub_dir = TempDir::new_in(&sub_dir).unwrap();
-
-        let mut fm = FileManager::new(dir.path());
-
-        // Create a lib.nr file at the root.
-        let file_name = Path::new("lib.nr");
-        create_dummy_file(&dir, file_name);
-
-        // Create another path with `./` and `../` inside it
-        let second_file_name = PathBuf::from(sub_sub_dir.path()).join("./../../lib.nr");
-
-        // Add both files to the file manager
-        let file_id = fm.add_file_with_source(file_name, "fn foo() {}".to_string()).unwrap();
-        let second_file_id =
-            fm.add_file_with_source(&second_file_name, "fn foo() {}".to_string()).unwrap();
+        let dir = PathBuf::new();
+        let mut fm = FileManager::new(&dir);
+
+        // Create a lib.nr file at the root and add it to the file manager.
+        let file_id = add_file(&mut fm, &dir.join("lib.nr"));
+
+        // Create another path with `./` and `../` inside it, and add it to the file manager
+        let sub_dir = dir.join("sub_dir");
+        let sub_sub_dir = sub_dir.join("sub_sub_dir");
+        let second_file_id = add_file(
+            &mut fm,
+            PathBuf::from(sub_sub_dir.as_path()).join("./../../lib.nr").as_path(),
+        );
 
         assert_eq!(file_id, second_file_id);
     }

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

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

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

@@ -1,3 +1,5 @@
+use std::io::IsTerminal;
+
 use crate::{FileDiagnostic, Location, Span};
 use codespan_reporting::diagnostic::{Diagnostic, Label};
 use codespan_reporting::files::Files;
@@ -148,7 +150,9 @@ pub fn report<'files>(
     call_stack: &[Location],
     deny_warnings: bool,
 ) -> bool {
-    let writer = StandardStream::stderr(ColorChoice::Always);
+    let color_choice =
+        if std::io::stderr().is_terminal() { ColorChoice::Auto } else { ColorChoice::Never };
+    let writer = StandardStream::stderr(color_choice);
     let config = codespan_reporting::term::Config::default();
 
     let stack_trace = stack_trace(files, call_stack);