chore!: update to 0.36.0 (#4)

Author: olehmisar

.github/workflows/test.yml

@@ -2,8 +2,8 @@ name: Noir tests
 
 on:
   push:
-   branches:
-    - master
+    branches:
+      - master
   pull_request:
 
 env:
@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [nightly, 0.34.0]
+        toolchain: [nightly, 0.36.0]
     steps:
       - name: Checkout sources
         uses: actions/checkout@v4
@@ -38,7 +38,30 @@ jobs:
       - name: Install Nargo
         uses: noir-lang/[email protected]
         with:
-          toolchain: 0.34.0
+          toolchain: 0.36.0
 
       - name: Run formatter
         run: nargo fmt --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:
+    name: Noir End
+    runs-on: ubuntu-latest
+    # We want this job to always run (even if the dependant jobs fail) as we want this job to fail rather than skipping.
+    if: ${{ always() }}
+    needs:
+      - test
+      - format
+
+    steps:
+      - name: Report overall success
+        run: |
+          if [[ $FAIL == true ]]; then
+              exit 1
+          else
+              exit 0
+          fi
+        env:
+          # We treat any cancelled, skipped or failing jobs as a failure for the workflow as a whole.
+          FAIL: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}

Nargo.toml

@@ -2,7 +2,7 @@
 name = "sparse_array"
 type = "lib"
 authors = [""]
-compiler_version = ">=0.34.0"
+compiler_version = ">=0.36.0"
 
 [dependencies]
-sort = {tag = "v0.1.0", git = "https://github.com/noir-lang/noir_sort"}
+sort = { tag = "v0.2.0", git = "https://github.com/noir-lang/noir_sort" }

src/lib.nr

@@ -8,7 +8,7 @@ unconstrained fn __sort_field_as_u32(lhs: Field, rhs: Field) -> bool {
 
 fn assert_sorted(lhs: Field, rhs: Field) {
     let result = (rhs - lhs - 1);
-    result.assert_max_bit_size(32);
+    result.assert_max_bit_size::<32>();
 }
 
 /**
@@ -22,21 +22,18 @@ fn assert_sorted(lhs: Field, rhs: Field) {
  *        1. keys[i] maps to values[i+1]
  *        2. values[0] is an empty object. when calling `get(idx)`, if `idx` is not in `keys` we will return `values[0]`
  **/
-struct MutSparseArrayBase<let N: u32, T, ComparisonFuncs>
-{
+struct MutSparseArrayBase<let N: u32, T, ComparisonFuncs> {
     values: [T; N + 3],
     keys: [Field; N + 2],
     linked_keys: [Field; N + 2],
     tail_ptr: Field,
-    maximum: Field
+    maximum: Field,
 }
 
-struct U32RangeTraits {
-}
+struct U32RangeTraits {}
 
-struct MutSparseArray<let N: u32, T>
-{
-    inner: MutSparseArrayBase<N, T, U32RangeTraits>
+pub struct MutSparseArray<let N: u32, T> {
+    inner: MutSparseArrayBase<N, T, U32RangeTraits>,
 }
 /**
  * @brief SparseArray, stores a sparse array of up to size 2^32 with `N` nonzero entries
@@ -49,19 +46,23 @@ struct MutSparseArray<let N: u32, T>
  *        1. keys[i] maps to values[i+1]
  *        2. values[0] is an empty object. when calling `get(idx)`, if `idx` is not in `keys` we will return `values[0]`
  **/
-struct SparseArray<let N: u32, T> {
+pub struct SparseArray<let N: u32, T> {
     keys: [Field; N + 2],
     values: [T; N + 3],
-    maximum: Field // can be up to 2^32
+    maximum: Field, // can be up to 2^32
 }
-impl<let N: u32, T> SparseArray<N, T> where T : std::default::Default {
+impl<let N: u32, T> SparseArray<N, T>
+where
+    T: std::default::Default,
+{
 
     /**
      * @brief construct a SparseArray
      **/
     fn create(_keys: [Field; N], _values: [T; N], size: Field) -> Self {
         let _maximum = size - 1;
-        let mut r: Self = SparseArray { keys: [0; N + 2], values: [T::default(); N + 3], maximum: _maximum };
+        let mut r: Self =
+            SparseArray { keys: [0; N + 2], values: [T::default(); N + 3], maximum: _maximum };
 
         // for any valid index, we want to ensure the following is satified:
         // self.keys[X] <= index <= self.keys[X+1]
@@ -71,16 +72,16 @@ impl<let N: u32, T> SparseArray<N, T> where T : std::default::Default {
         // insert start and endpoints
         r.keys[0] = 0;
         for i in 0..N {
-            r.keys[i+1] = sorted_keys.sorted[i];
+            r.keys[i + 1] = sorted_keys.sorted[i];
         }
-        r.keys[N+1] = _maximum;
+        r.keys[N + 1] = _maximum;
 
         // populate values based on the sorted keys
         // note: self.keys[i] maps to self.values[i+1]
         // self.values[0] does not map to any key. we use it to store the default empty value,
         // which is returned when `get(idx)` is called and `idx` does not exist in `self.keys`
         for i in 0..N {
-            r.values[i+2] = _values[sorted_keys.sort_indices[i]];
+            r.values[i + 2] = _values[sorted_keys.sort_indices[i]];
         }
         // insert values that map to our key start and endpoints
         // if _keys[0] = 0 then values[0] must equal _values[0], so some conditional logic is required
@@ -91,20 +92,20 @@ impl<let N: u32, T> SparseArray<N, T> where T : std::default::Default {
         }
         let mut final_value = T::default();
         if (_keys[N - 1] == _maximum) {
-            final_value = _values[N-1];
+            final_value = _values[N - 1];
         }
         r.values[1] = initial_value;
-        r.values[N+2] = final_value;
+        r.values[N + 2] = final_value;
 
         // perform boundary checks!
         // the maximum size of the sparse array is 2^32
         // we need to check that every element in `self.keys` is less than 2^32
         // because `self.keys` is sorted, we can simply validate that
         // sorted_keys.sorted[0] < 2^32
         // sorted_keys.sorted[N-1] < maximum
-        sorted_keys.sorted[0].assert_max_bit_size(32);
-        _maximum.assert_max_bit_size(32);
-        (_maximum - sorted_keys.sorted[N - 1]).assert_max_bit_size(32);
+        sorted_keys.sorted[0].assert_max_bit_size::<32>();
+        _maximum.assert_max_bit_size::<32>();
+        (_maximum - sorted_keys.sorted[N - 1]).assert_max_bit_size::<32>();
         r
     }
 
@@ -138,9 +139,7 @@ impl<let N: u32, T> SparseArray<N, T> where T : std::default::Default {
      * @details cost is 14.5 gates per lookup
      **/
     fn get(self, idx: Field) -> T {
-        let (found, found_index) = unsafe {
-            self.search_for_key(idx)
-        };
+        let (found, found_index) = unsafe { self.search_for_key(idx) };
         // bool check. 0.25 gates cheaper than a raw `bool` type. need to fix at some point
         assert(found * found == found);
 
@@ -156,8 +155,8 @@ impl<let N: u32, T> SparseArray<N, T> where T : std::default::Default {
         let rhs = self.keys[found_index + 1 - found];
         let lhs_condition = idx - lhs - 1 + found;
         let rhs_condition = rhs - 1 + found - idx;
-        lhs_condition.assert_max_bit_size(32);
-        rhs_condition.assert_max_bit_size(32);
+        lhs_condition.assert_max_bit_size::<32>();
+        rhs_condition.assert_max_bit_size::<32>();
 
         // self.keys[i] maps to self.values[i+1]
         // however...if we did not find a non-sparse entry, we want to return self.values[0] (the default value)
@@ -170,7 +169,7 @@ mod test {
 
     use crate::SparseArray;
     #[test]
-fn test_sparse_lookup() {
+    fn test_sparse_lookup() {
         let example = SparseArray::create([1, 99, 7, 5], [123, 101112, 789, 456], 100);
 
         assert(example.get(1) == 123);
@@ -186,12 +185,12 @@ fn test_sparse_lookup() {
     }
 
     #[test]
-fn test_sparse_lookup_boundary_cases() {
+    fn test_sparse_lookup_boundary_cases() {
         // what about when keys[0] = 0 and keys[N-1] = 2^32 - 1?
         let example = SparseArray::create(
             [0, 99999, 7, 0xffffffff],
             [123, 101112, 789, 456],
-            0x100000000
+            0x100000000,
         );
 
         assert(example.get(0) == 123);
@@ -202,30 +201,32 @@ fn test_sparse_lookup_boundary_cases() {
     }
 
     #[test(should_fail_with = "call to assert_max_bit_size")]
-fn test_sparse_lookup_overflow() {
+    fn test_sparse_lookup_overflow() {
         let example = SparseArray::create([1, 5, 7, 99999], [123, 456, 789, 101112], 100000);
 
         assert(example.get(100000) == 0);
     }
 
     #[test(should_fail_with = "call to assert_max_bit_size")]
-fn test_sparse_lookup_boundary_case_overflow() {
-        let example = SparseArray::create([0, 5, 7, 0xffffffff], [123, 456, 789, 101112], 0x100000000);
+    fn test_sparse_lookup_boundary_case_overflow() {
+        let example =
+            SparseArray::create([0, 5, 7, 0xffffffff], [123, 456, 789, 101112], 0x100000000);
 
         assert(example.get(0x100000000) == 0);
     }
 
     #[test(should_fail_with = "call to assert_max_bit_size")]
-fn test_sparse_lookup_key_exceeds_maximum() {
-        let example = SparseArray::create([0, 5, 7, 0xffffffff], [123, 456, 789, 101112], 0xffffffff);
+    fn test_sparse_lookup_key_exceeds_maximum() {
+        let example =
+            SparseArray::create([0, 5, 7, 0xffffffff], [123, 456, 789, 101112], 0xffffffff);
         assert(example.maximum == 0xffffffff);
     }
     #[test]
-fn test_sparse_lookup_u32() {
+    fn test_sparse_lookup_u32() {
         let example = SparseArray::create(
             [1, 99, 7, 5],
             [123 as u32, 101112 as u32, 789 as u32, 456 as u32],
-            100
+            100,
         );
 
         assert(example.get(1) == 123);
@@ -241,8 +242,8 @@ fn test_sparse_lookup_u32() {
     }
 
     struct F {
-    foo: [Field; 3]
-}
+        foo: [Field; 3],
+    }
     impl std::cmp::Eq for F {
         fn eq(self, other: Self) -> bool {
             self.foo == other.foo
@@ -256,8 +257,13 @@ fn test_sparse_lookup_u32() {
     }
 
     #[test]
-fn test_sparse_lookup_struct() {
-        let values = [F { foo: [1, 2, 3] }, F { foo: [4, 5, 6] }, F { foo: [7, 8, 9] }, F { foo: [10, 11, 12] }];
+    fn test_sparse_lookup_struct() {
+        let values = [
+            F { foo: [1, 2, 3] },
+            F { foo: [4, 5, 6] },
+            F { foo: [7, 8, 9] },
+            F { foo: [10, 11, 12] },
+        ];
         let example = SparseArray::create([1, 99, 7, 5], values, 100000);
 
         assert(example.get(1) == values[0]);