From 5b2b1a8ad5532b34e8812f67aa875a593731d525 Mon Sep 17 00:00:00 2001
From: kek kek kek <andriy.n@obox.systems>
Date: Fri, 27 Oct 2023 10:44:09 -0700
Subject: [PATCH] chore: format integration tests  (#3257)

Co-authored-by: jfecher <jfecher11@gmail.com>
---
 .../circuits/recursion/src/main.nr            |  10 +-
 .../fixtures/simple/noir-script/src/main.nr   |   2 +-
 noir_stdlib/src/eddsa.nr                      |   9 +-
 .../brillig_assert_fail/src/main.nr           |   2 +-
 .../div_by_zero_constants/src/main.nr         |   2 +-
 .../div_by_zero_modulo/src/main.nr            |  10 +-
 .../dup_trait_implementation_4/src/main.nr    |   3 +-
 .../dup_trait_implementation_5/src/main.nr    |   3 +-
 .../duplicate_declaration/src/main.nr         |   2 +-
 .../dyn_index_fail_nested_array/src/main.nr   |   2 +-
 .../dynamic_index_failure/src/main.nr         |   2 +-
 .../compile_failure/field_modulo/src/main.nr  |   1 -
 .../overflowing_assignment/src/main.nr        |   2 +-
 .../slice_insert_failure/src/main.nr          |   2 +-
 .../slice_remove_failure/src/main.nr          |   2 +-
 .../non_entry_point_method/src/main.nr        |   2 +-
 .../attributes_multiple/src/main.nr           |   3 +-
 .../auto_deref/src/main.nr                    |   1 -
 .../src/main.nr                               |   4 +-
 .../brillig_to_bits/src/main.nr               |   1 -
 .../closure_explicit_types/src/main.nr        |   7 +-
 .../comptime_sort/src/main.nr                 |   3 +-
 .../conditional_regression_547/src/main.nr    |   7 +-
 .../ec_baby_jubjub/src/main.nr                | 121 ++++++------------
 .../generators/src/main.nr                    |   8 +-
 .../higher_order_fn_selector/src/main.nr      |   9 +-
 .../intrinsic_die/src/main.nr                 |   4 +-
 .../compile_success_empty/option/src/main.nr  |   1 -
 .../regression_2099/src/main.nr               |  23 ++--
 .../ret_fn_ret_cl/src/main.nr                 |   2 -
 .../simple_program_no_body/src/main.nr        |   2 +-
 .../simple_range/src/main.nr                  |   4 +-
 .../specialization/src/main.nr                |   4 +-
 .../str_as_bytes/src/main.nr                  |  24 ++--
 .../compile_success_empty/to_bits/src/main.nr |   2 -
 .../unconstrained_empty/src/main.nr           |   3 +-
 .../compile_success_empty/unit/src/main.nr    |   8 +-
 .../unused_variables/src/main.nr              |   4 +-
 .../1327_concrete_in_generic/src/main.nr      |   4 +-
 .../tests/execution_success/2_div/src/main.nr |   2 +-
 .../tests/execution_success/3_add/src/main.nr |   2 +-
 .../tests/execution_success/6/src/main.nr     |   4 +-
 .../execution_success/7_function/src/main.nr  |  19 ++-
 .../array_dynamic/src/main.nr                 |   8 +-
 .../execution_success/array_eq/src/main.nr    |   2 +-
 .../execution_success/array_neq/src/main.nr   |   2 +-
 .../execution_success/bit_and/src/main.nr     |   2 +-
 .../bit_shifts_comptime/src/main.nr           |  14 +-
 .../bit_shifts_runtime/src/main.nr            |   8 +-
 .../brillig_conditional/src/main.nr           |   6 +-
 .../brillig_keccak/src/main.nr                |   6 +-
 .../brillig_nested_arrays/src/main.nr         |  12 +-
 .../brillig_pedersen/src/main.nr              |   2 +-
 .../brillig_recursion/src/main.nr             |   6 +-
 .../brillig_references/src/main.nr            |   7 +-
 .../brillig_scalar_mul/src/main.nr            |   6 +-
 .../brillig_schnorr/src/main.nr               |   4 +-
 .../brillig_to_bytes_integration/src/main.nr  |   2 +-
 .../conditional_1/src/main.nr                 |   4 +-
 .../conditional_2/src/main.nr                 |   2 +-
 .../conditional_regression_421/src/main.nr    |  12 +-
 .../conditional_regression_661/src/main.nr    |   2 +-
 .../src/main.nr                               |   2 +-
 .../double_verify_proof/src/main.nr           |  12 +-
 .../ecdsa_secp256k1/src/main.nr               |   4 +-
 .../ecdsa_secp256r1/src/main.nr               |   2 +-
 .../tests/execution_success/eddsa/src/main.nr |   2 +-
 .../field_attribute/src/main.nr               |   2 +-
 .../global_consts/src/main.nr                 |  24 ++--
 .../if_else_chain/src/main.nr                 |   2 +-
 .../execution_success/keccak256/src/main.nr   |   6 +-
 .../execution_success/mock_oracle/src/main.nr |   9 +-
 .../nested_array_dynamic/src/main.nr          |   5 +-
 .../nested_arrays_from_brillig/src/main.nr    |   6 +-
 .../nested_slice_dynamic/src/main.nr          |   2 +-
 .../pedersen_check/src/main.nr                |   2 +-
 .../poseidonsponge_x5_254/src/main.nr         |   2 +-
 .../execution_success/references/src/main.nr  |  14 +-
 .../execution_success/regression/src/main.nr  |  53 ++++----
 .../regression_mem_op_predicate/src/main.nr   |   6 +-
 .../execution_success/scalar_mul/src/main.nr  |   6 +-
 .../execution_success/schnorr/src/main.nr     |   4 +-
 .../execution_success/sha2_blocks/src/main.nr |  25 +++-
 .../execution_success/sha2_byte/src/main.nr   |   4 +-
 .../simple_2d_array/src/main.nr               |   2 +-
 .../execution_success/slices/src/main.nr      |  11 +-
 .../execution_success/strings/src/main.nr     |   2 +-
 .../execution_success/struct/src/main.nr      |  10 +-
 .../execution_success/to_be_bytes/src/main.nr |   4 +-
 .../to_bytes_integration/src/main.nr          |   2 +-
 .../tuple_inputs/src/main.nr                  |   1 +
 .../execution_success/tuples/src/main.nr      |   8 +-
 .../type_aliases/src/main.nr                  |   4 +-
 .../should_fail_mismatch/src/main.nr          |   3 +-
 .../test_libraries/diamond_deps_2/src/lib.nr  |   1 -
 .../assert_lt/src/main.nr                     |   4 +-
 96 files changed, 279 insertions(+), 406 deletions(-)

diff --git a/compiler/integration-tests/circuits/recursion/src/main.nr b/compiler/integration-tests/circuits/recursion/src/main.nr
index ffa3ccef90e..bc1f3e76d1d 100644
--- a/compiler/integration-tests/circuits/recursion/src/main.nr
+++ b/compiler/integration-tests/circuits/recursion/src/main.nr
@@ -6,15 +6,9 @@ fn main(
     public_inputs : [Field; 1], 
     key_hash : Field, 
     input_aggregation_object : [Field; 16],
-) -> pub [Field;16]{
+) -> pub [Field; 16] {
     let vk : [Field] = verification_key;
     let p : [Field] = proof;
     let pi : [Field] = public_inputs;
-    std::verify_proof(
-        vk, 
-        p, 
-        pi, 
-        key_hash, 
-        input_aggregation_object
-    )
+    std::verify_proof(vk, p, pi, key_hash, input_aggregation_object)
 }
diff --git a/compiler/wasm/fixtures/simple/noir-script/src/main.nr b/compiler/wasm/fixtures/simple/noir-script/src/main.nr
index 36fcc1916f5..b1889529f86 100644
--- a/compiler/wasm/fixtures/simple/noir-script/src/main.nr
+++ b/compiler/wasm/fixtures/simple/noir-script/src/main.nr
@@ -1,3 +1,3 @@
 fn main(x : u64, y : pub u64) {
-  assert(x < y);
+    assert(x < y);
 }
diff --git a/noir_stdlib/src/eddsa.nr b/noir_stdlib/src/eddsa.nr
index ff8c1da1397..31fac549fc5 100644
--- a/noir_stdlib/src/eddsa.nr
+++ b/noir_stdlib/src/eddsa.nr
@@ -33,7 +33,6 @@ pub fn eddsa_poseidon_verify(
 ) -> bool {
     // Verifies by testing:
     // S * B8 = R8 + H(R8, A, m) * A8
-
     let bjj = baby_jubjub();
 
     let pub_key = TEPoint::new(pub_key_x, pub_key_y);
@@ -46,13 +45,7 @@ pub fn eddsa_poseidon_verify(
     assert(lt_bytes32(signature_s, bjj.suborder));
 
     // Calculate the h = H(R, A, msg)
-    let hash: Field = poseidon::bn254::hash_5([
-        signature_r8_x,
-        signature_r8_y,
-        pub_key_x,
-        pub_key_y,
-        message,
-    ]);
+    let hash: Field = poseidon::bn254::hash_5([signature_r8_x, signature_r8_y, pub_key_x, pub_key_y, message]);
 
     // Calculate second part of the right side:  right2 = h*8*A
 
diff --git a/tooling/nargo_cli/tests/compile_failure/brillig_assert_fail/src/main.nr b/tooling/nargo_cli/tests/compile_failure/brillig_assert_fail/src/main.nr
index 801a818c816..e9379a29876 100644
--- a/tooling/nargo_cli/tests/compile_failure/brillig_assert_fail/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/brillig_assert_fail/src/main.nr
@@ -1,7 +1,7 @@
 // Tests a very simple program.
 // 
 // The features being tested is using assert on brillig
-fn main(x: Field)  {
+fn main(x: Field) {
     assert(1 == conditional(x as bool));
 }
 
diff --git a/tooling/nargo_cli/tests/compile_failure/div_by_zero_constants/src/main.nr b/tooling/nargo_cli/tests/compile_failure/div_by_zero_constants/src/main.nr
index 2259d51e6de..58adc5444b1 100644
--- a/tooling/nargo_cli/tests/compile_failure/div_by_zero_constants/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/div_by_zero_constants/src/main.nr
@@ -3,4 +3,4 @@ use dep::std;
 fn main() {
     let a: Field = 3 / 0;
     std::println(a);
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/div_by_zero_modulo/src/main.nr b/tooling/nargo_cli/tests/compile_failure/div_by_zero_modulo/src/main.nr
index f20c39486e0..d938ab7fca8 100644
--- a/tooling/nargo_cli/tests/compile_failure/div_by_zero_modulo/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/div_by_zero_modulo/src/main.nr
@@ -1,7 +1,7 @@
 fn main() {
     let a: u32 = 6;
-	let b = 3;
-	let c = 0;
-	let res = (a*b) % c;
-	assert(res != 5);
-}
\ No newline at end of file
+    let b = 3;
+    let c = 0;
+    let res = (a * b) % c;
+    assert(res != 5);
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_4/src/main.nr b/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_4/src/main.nr
index b9f712ceff0..e03fe8b3eeb 100644
--- a/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_4/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_4/src/main.nr
@@ -2,5 +2,4 @@ mod module1;
 mod module2;
 mod module3;
 
-fn main() {
-}
+fn main() {}
diff --git a/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_5/src/main.nr b/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_5/src/main.nr
index 78e3867e4a1..b5719009898 100644
--- a/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_5/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/dup_trait_implementation_5/src/main.nr
@@ -3,5 +3,4 @@ mod module2;
 mod module3;
 mod module4;
 
-fn main() {
-}
+fn main() {}
diff --git a/tooling/nargo_cli/tests/compile_failure/duplicate_declaration/src/main.nr b/tooling/nargo_cli/tests/compile_failure/duplicate_declaration/src/main.nr
index 09337e51c93..4803f2005c9 100644
--- a/tooling/nargo_cli/tests/compile_failure/duplicate_declaration/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/duplicate_declaration/src/main.nr
@@ -5,4 +5,4 @@ fn hello(x : Field) -> Field {
 
 fn hello(x : Field) -> Field {
     x
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/dyn_index_fail_nested_array/src/main.nr b/tooling/nargo_cli/tests/compile_failure/dyn_index_fail_nested_array/src/main.nr
index e26625457d9..9f2ae3a0618 100644
--- a/tooling/nargo_cli/tests/compile_failure/dyn_index_fail_nested_array/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/dyn_index_fail_nested_array/src/main.nr
@@ -5,4 +5,4 @@ struct Foo {
 
 fn main(mut x : [Foo; 3], y : pub Field) {
     assert(x[y + 2].a == 5);
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/dynamic_index_failure/src/main.nr b/tooling/nargo_cli/tests/compile_failure/dynamic_index_failure/src/main.nr
index 2665356ccd6..10d4d1f02d1 100644
--- a/tooling/nargo_cli/tests/compile_failure/dynamic_index_failure/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/dynamic_index_failure/src/main.nr
@@ -20,4 +20,4 @@ fn main(mut x: [u32; 5], z: Field) {
     //     }
     // }
     // assert(x[idx] != 0);
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/field_modulo/src/main.nr b/tooling/nargo_cli/tests/compile_failure/field_modulo/src/main.nr
index b27ba0892b3..a482b68806b 100644
--- a/tooling/nargo_cli/tests/compile_failure/field_modulo/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/field_modulo/src/main.nr
@@ -1,4 +1,3 @@
-
 fn main(x: Field) -> pub Field {
     x % 2
 }
diff --git a/tooling/nargo_cli/tests/compile_failure/overflowing_assignment/src/main.nr b/tooling/nargo_cli/tests/compile_failure/overflowing_assignment/src/main.nr
index 78535a853a6..6b529103ca3 100644
--- a/tooling/nargo_cli/tests/compile_failure/overflowing_assignment/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/overflowing_assignment/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
     let x:u8 = -1;
     let y:u8 = 300;
-    assert(x!=y);
+    assert(x != y);
 }
diff --git a/tooling/nargo_cli/tests/compile_failure/slice_insert_failure/src/main.nr b/tooling/nargo_cli/tests/compile_failure/slice_insert_failure/src/main.nr
index dad80bff7ab..72918037c16 100644
--- a/tooling/nargo_cli/tests/compile_failure/slice_insert_failure/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/slice_insert_failure/src/main.nr
@@ -8,4 +8,4 @@ fn main(x : Field, y : pub Field) {
     }
 
     slice = slice.insert(10, 100);
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_failure/slice_remove_failure/src/main.nr b/tooling/nargo_cli/tests/compile_failure/slice_remove_failure/src/main.nr
index 7c308488ae8..1cd335f4b34 100644
--- a/tooling/nargo_cli/tests/compile_failure/slice_remove_failure/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_failure/slice_remove_failure/src/main.nr
@@ -8,4 +8,4 @@ fn main(x : Field, y : pub Field) {
     }
 
     let (removed_slice, removed_elem) = slice.remove(10);
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/src/main.nr b/tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/src/main.nr
index 5c7152029c9..f1b739e4b88 100644
--- a/tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/src/main.nr
@@ -3,4 +3,4 @@ contract Foo {
     
     #[contract_library_method]
     fn has_mut(_context : &mut PlaceholderStruct) {}
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/attributes_multiple/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/attributes_multiple/src/main.nr
index 46b761065ff..581fb989b4c 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/attributes_multiple/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/attributes_multiple/src/main.nr
@@ -1,8 +1,7 @@
-
 fn main() {
     another_func()
 }
 
 #[aztec(private)]
 #[internal]
-fn another_func() {}
\ No newline at end of file
+fn another_func() {}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/auto_deref/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/auto_deref/src/main.nr
index e0b4a447fd0..d69aff7e0d4 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/auto_deref/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/auto_deref/src/main.nr
@@ -1,4 +1,3 @@
-
 fn main() {
     let a = &mut &mut &mut [1, 2, 3];
     assert(a[0] == 1);
diff --git a/tooling/nargo_cli/tests/compile_success_empty/brillig_field_binary_operations/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/brillig_field_binary_operations/src/main.nr
index e7b0afccc3e..85002cef01d 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/brillig_field_binary_operations/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/brillig_field_binary_operations/src/main.nr
@@ -1,5 +1,5 @@
 // Tests arithmetic operations on fields
-fn main()  {
+fn main() {
     let x = 4;
     let y = 2;
     assert((x + y) == add(x, y));
@@ -22,4 +22,4 @@ unconstrained fn mul(x : Field, y : Field) -> Field {
 
 unconstrained fn div(x : Field, y : Field) -> Field {
     x / y
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/brillig_to_bits/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/brillig_to_bits/src/main.nr
index a2ab0d4bc5a..294da58f68a 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/brillig_to_bits/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/brillig_to_bits/src/main.nr
@@ -20,5 +20,4 @@ unconstrained fn main() {
         let le_bit = le_bits_x[3-i];
         assert(be_bit == le_bit);
     }
-
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/closure_explicit_types/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/closure_explicit_types/src/main.nr
index 133bc1b4206..b5008c5d6dd 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/closure_explicit_types/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/closure_explicit_types/src/main.nr
@@ -1,4 +1,3 @@
-
 fn ret_normal_lambda1() -> fn() -> Field {
     || 10
 }
@@ -70,10 +69,10 @@ fn main() {
     assert(accepts_closure3(|| y as u64 + z) == 70);
 
     let w = 50;
-    assert(add_results(|| 100, || x ) == 150);
-    assert(add_results(|| x + 100, || w + x ) == 250);
+    assert(add_results(|| 100, || x) == 150);
+    assert(add_results(|| x + 100, || w + x) == 250);
 
-    let arr = [1,2,3,4];
+    let arr = [1, 2, 3, 4];
 
     assert(map(arr, |n| n + 1) == [2, 3, 4, 5]);
     assert(map(arr, |n| n + x) == [51, 52, 53, 54]);
diff --git a/tooling/nargo_cli/tests/compile_success_empty/comptime_sort/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/comptime_sort/src/main.nr
index f8bd38654c0..a24a6ebaba6 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/comptime_sort/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/comptime_sort/src/main.nr
@@ -1,6 +1,5 @@
-
 fn main() {
-    let unsorted: [u8; 3] = [3,1,2];
+    let unsorted: [u8; 3] = [3, 1, 2];
     let sorted = unsorted.sort();
     assert(sorted[0] == 1);
     assert(sorted[1] == 2);
diff --git a/tooling/nargo_cli/tests/compile_success_empty/conditional_regression_547/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/conditional_regression_547/src/main.nr
index 41ccbb00a2a..f97199288a4 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/conditional_regression_547/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/conditional_regression_547/src/main.nr
@@ -13,10 +13,5 @@ fn main(x: Field) -> pub Field {
 }
 
 fn safe_inverse(n: Field) -> Field {
-    if n == 0 {
-        0
-    }
-    else {
-        1 / n
-    }
+    if n == 0 { 0 } else { 1 / n }
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/ec_baby_jubjub/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/ec_baby_jubjub/src/main.nr
index 3372e969d4b..2060ac57e31 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/ec_baby_jubjub/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/ec_baby_jubjub/src/main.nr
@@ -13,39 +13,39 @@ use dep::std::ec::montcurve::curvegroup::Point as MG;
 
 fn main() {
     // This test only makes sense if Field is the right prime field.
-    if 21888242871839275222246405745257275088548364400416034343698204186575808495617 == 0
-    {
+    if 21888242871839275222246405745257275088548364400416034343698204186575808495617 == 0 {
         // Define Baby Jubjub (ERC-2494) parameters in affine representation
-        let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+        let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(
+                995203441582195749578291179787384436505546430278305826713579947235728471134, 5472060717959818805561601436314318772137091100104008585924551046643952123905
+            ));
 
         // Test addition
-        let p1_affine = Gaffine::new(17777552123799933955779906779655732241715742912184938656739573121738514868268, 2626589144620713026669568689430873010625803728049924121243784502389097019475);
-        let p2_affine = Gaffine::new(16540640123574156134436876038791482806971768689494387082833631921987005038935, 20819045374670962167435360035096875258406992893633759881276124905556507972311);
-        
-        let p3_affine = bjj_affine.add(p1_affine, p2_affine);
-        assert(
-            p3_affine.eq(Gaffine::new(
-                7916061937171219682591368294088513039687205273691143098332585753343424131937,
-                14035240266687799601661095864649209771790948434046947201833777492504781204499
-            ))
+        let p1_affine = Gaffine::new(
+            17777552123799933955779906779655732241715742912184938656739573121738514868268, 2626589144620713026669568689430873010625803728049924121243784502389097019475
         );
+        let p2_affine = Gaffine::new(
+            16540640123574156134436876038791482806971768689494387082833631921987005038935, 20819045374670962167435360035096875258406992893633759881276124905556507972311
+        );
+
+        let p3_affine = bjj_affine.add(p1_affine, p2_affine);
+        assert(p3_affine.eq(Gaffine::new(
+                7916061937171219682591368294088513039687205273691143098332585753343424131937, 14035240266687799601661095864649209771790948434046947201833777492504781204499
+            )));
 
         // Test scalar multiplication
         let p4_affine = bjj_affine.mul(2, p1_affine);
-        assert(
-            p4_affine.eq(Gaffine::new(
-                6890855772600357754907169075114257697580319025794532037257385534741338397365,
-                4338620300185947561074059802482547481416142213883829469920100239455078257889
-            ))
-        );
-        assert(p4_affine.eq(bjj_affine.bit_mul([0,1], p1_affine)));
+        assert(p4_affine.eq(Gaffine::new(
+            6890855772600357754907169075114257697580319025794532037257385534741338397365,
+            4338620300185947561074059802482547481416142213883829469920100239455078257889,
+        )));
+        assert(p4_affine.eq(bjj_affine.bit_mul([0, 1], p1_affine)));
 
         // Test subtraction
         let p5_affine = bjj_affine.subtract(p3_affine, p3_affine);
         assert(p5_affine.eq(Gaffine::zero()));
 
         // Check that these points are on the curve
-        assert(
+         assert(
             bjj_affine.contains(bjj_affine.gen) &
             bjj_affine.contains(p1_affine) &
             bjj_affine.contains(p2_affine) &
@@ -56,7 +56,6 @@ fn main() {
         
         // Test CurveGroup equivalents
         let bjj = bjj_affine.into_group(); // Baby Jubjub
-
         let p1 = p1_affine.into_group();
         let p2 = p2_affine.into_group();
         let p3 = p3_affine.into_group();
@@ -68,21 +67,14 @@ fn main() {
 
         // Test scalar multiplication
         assert(p4.eq(bjj.mul(2, p1)));
-        assert(p4.eq(bjj.bit_mul([0,1], p1)));
+        assert(p4.eq(bjj.bit_mul([0, 1], p1)));
 
         // Test subtraction
         assert(G::zero().eq(bjj.subtract(p3, p3)));
         assert(p5.eq(G::zero()));
 
         // Check that these points are on the curve
-        assert(
-            bjj.contains(bjj.gen) &
-            bjj.contains(p1) &
-            bjj.contains(p2) &
-            bjj.contains(p3) &
-            bjj.contains(p4) &
-            bjj.contains(p5)
-        );
+        assert(bjj.contains(bjj.gen) & bjj.contains(p1) & bjj.contains(p2) & bjj.contains(p3) & bjj.contains(p4) & bjj.contains(p5));
         
         // Test SWCurve equivalents of the above
         // First the affine representation
@@ -95,32 +87,18 @@ fn main() {
         let p5_swcurve_affine = bjj_affine.map_into_swcurve(p5_affine);
         
         // Addition
-        assert(
-            p3_swcurve_affine.eq(
-                bjj_swcurve_affine.add(
-                p1_swcurve_affine,
-                p2_swcurve_affine
-                )
-            )
-        );
+        assert(p3_swcurve_affine.eq(bjj_swcurve_affine.add(p1_swcurve_affine, p2_swcurve_affine)));
         
         // Doubling
         assert(p4_swcurve_affine.eq(bjj_swcurve_affine.mul(2, p1_swcurve_affine)));
-        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.bit_mul([0,1], p1_swcurve_affine)));
+        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.bit_mul([0, 1], p1_swcurve_affine)));
 
         // Subtraction
         assert(SWGaffine::zero().eq(bjj_swcurve_affine.subtract(p3_swcurve_affine, p3_swcurve_affine)));
         assert(p5_swcurve_affine.eq(SWGaffine::zero()));
 
         // Check that these points are on the curve
-        assert(
-            bjj_swcurve_affine.contains(bjj_swcurve_affine.gen) &
-            bjj_swcurve_affine.contains(p1_swcurve_affine) &
-            bjj_swcurve_affine.contains(p2_swcurve_affine) &
-            bjj_swcurve_affine.contains(p3_swcurve_affine) &
-            bjj_swcurve_affine.contains(p4_swcurve_affine) &
-            bjj_swcurve_affine.contains(p5_swcurve_affine)
-        );
+        assert(bjj_swcurve_affine.contains(bjj_swcurve_affine.gen) & bjj_swcurve_affine.contains(p1_swcurve_affine) & bjj_swcurve_affine.contains(p2_swcurve_affine) & bjj_swcurve_affine.contains(p3_swcurve_affine) & bjj_swcurve_affine.contains(p4_swcurve_affine) & bjj_swcurve_affine.contains(p5_swcurve_affine));
         
         // Then the CurveGroup representation
         let bjj_swcurve = bjj.into_swcurve();
@@ -132,25 +110,18 @@ fn main() {
         let p5_swcurve = bjj.map_into_swcurve(p5);
         
         // Addition
-        assert(p3_swcurve.eq(bjj_swcurve.add(p1_swcurve,p2_swcurve)));
+        assert(p3_swcurve.eq(bjj_swcurve.add(p1_swcurve, p2_swcurve)));
         
         // Doubling
         assert(p4_swcurve.eq(bjj_swcurve.mul(2, p1_swcurve)));
-        assert(p4_swcurve.eq(bjj_swcurve.bit_mul([0,1], p1_swcurve)));
+        assert(p4_swcurve.eq(bjj_swcurve.bit_mul([0, 1], p1_swcurve)));
 
         // Subtraction
         assert(SWG::zero().eq(bjj_swcurve.subtract(p3_swcurve, p3_swcurve)));
         assert(p5_swcurve.eq(SWG::zero()));
 
         // Check that these points are on the curve
-        assert(
-            bjj_swcurve.contains(bjj_swcurve.gen) &
-            bjj_swcurve.contains(p1_swcurve) &
-            bjj_swcurve.contains(p2_swcurve) &
-            bjj_swcurve.contains(p3_swcurve) &
-            bjj_swcurve.contains(p4_swcurve) &
-            bjj_swcurve.contains(p5_swcurve)
-        );
+        assert(bjj_swcurve.contains(bjj_swcurve.gen) & bjj_swcurve.contains(p1_swcurve) & bjj_swcurve.contains(p2_swcurve) & bjj_swcurve.contains(p3_swcurve) & bjj_swcurve.contains(p4_swcurve) & bjj_swcurve.contains(p5_swcurve));
 
         // Test MontCurve conversions
         // First the affine representation
@@ -167,21 +138,14 @@ fn main() {
         
         // Doubling
         assert(p4_montcurve_affine.eq(bjj_montcurve_affine.mul(2, p1_montcurve_affine)));
-        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.bit_mul([0,1], p1_montcurve_affine)));
+        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.bit_mul([0, 1], p1_montcurve_affine)));
 
         // Subtraction
         assert(MGaffine::zero().eq(bjj_montcurve_affine.subtract(p3_montcurve_affine, p3_montcurve_affine)));
         assert(p5_montcurve_affine.eq(MGaffine::zero()));
 
         // Check that these points are on the curve
-        assert(
-            bjj_montcurve_affine.contains(bjj_montcurve_affine.gen) &
-            bjj_montcurve_affine.contains(p1_montcurve_affine) &
-            bjj_montcurve_affine.contains(p2_montcurve_affine) &
-            bjj_montcurve_affine.contains(p3_montcurve_affine) &
-            bjj_montcurve_affine.contains(p4_montcurve_affine) &
-            bjj_montcurve_affine.contains(p5_montcurve_affine)
-        );
+        assert(bjj_montcurve_affine.contains(bjj_montcurve_affine.gen) & bjj_montcurve_affine.contains(p1_montcurve_affine) & bjj_montcurve_affine.contains(p2_montcurve_affine) & bjj_montcurve_affine.contains(p3_montcurve_affine) & bjj_montcurve_affine.contains(p4_montcurve_affine) & bjj_montcurve_affine.contains(p5_montcurve_affine));
 
         // Then the CurveGroup representation
         let bjj_montcurve = bjj.into_montcurve();
@@ -197,30 +161,27 @@ fn main() {
 
         // Doubling
         assert(p4_montcurve.eq(bjj_montcurve.mul(2, p1_montcurve)));
-        assert(p4_montcurve.eq(bjj_montcurve.bit_mul([0,1], p1_montcurve)));
+        assert(p4_montcurve.eq(bjj_montcurve.bit_mul([0, 1], p1_montcurve)));
 
         // Subtraction
         assert(MG::zero().eq(bjj_montcurve.subtract(p3_montcurve, p3_montcurve)));
         assert(p5_montcurve.eq(MG::zero()));
 
         // Check that these points are on the curve
-        assert(
-            bjj_montcurve.contains(bjj_montcurve.gen) &
-            bjj_montcurve.contains(p1_montcurve) &
-            bjj_montcurve.contains(p2_montcurve) &
-            bjj_montcurve.contains(p3_montcurve) &
-            bjj_montcurve.contains(p4_montcurve) &
-            bjj_montcurve.contains(p5_montcurve)
-        );
+        assert(bjj_montcurve.contains(bjj_montcurve.gen) & bjj_montcurve.contains(p1_montcurve) & bjj_montcurve.contains(p2_montcurve) & bjj_montcurve.contains(p3_montcurve) & bjj_montcurve.contains(p4_montcurve) & bjj_montcurve.contains(p5_montcurve));
         
         // Elligator 2 map-to-curve
         let ell2_pt_map = bjj_affine.elligator2_map(27);
 
-        assert(ell2_pt_map.eq(MGaffine::new(7972459279704486422145701269802978968072470631857513331988813812334797879121, 8142420778878030219043334189293412482212146646099536952861607542822144507872).into_tecurve()));
+        assert(ell2_pt_map.eq(MGaffine::new(
+                7972459279704486422145701269802978968072470631857513331988813812334797879121, 8142420778878030219043334189293412482212146646099536952861607542822144507872
+            ).into_tecurve()));
 
         // SWU map-to-curve
-        let swu_pt_map = bjj_affine.swu_map(5,27);
-        
-        assert(swu_pt_map.eq(bjj_affine.map_from_swcurve(SWGaffine::new(2162719247815120009132293839392097468339661471129795280520343931405114293888, 5341392251743377373758788728206293080122949448990104760111875914082289313973))));        
-    }            
+        let swu_pt_map = bjj_affine.swu_map(5, 27);
+
+        assert(swu_pt_map.eq(bjj_affine.map_from_swcurve(SWGaffine::new(
+                    2162719247815120009132293839392097468339661471129795280520343931405114293888, 5341392251743377373758788728206293080122949448990104760111875914082289313973
+                ))));
+    }
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/generators/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/generators/src/main.nr
index 2f6f90a8c57..9a65c5fd3d2 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/generators/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/generators/src/main.nr
@@ -28,7 +28,7 @@ fn fibonacci_generator() -> fn[(&mut Field, &mut Field)]() -> Field {
 
 // we'll be able to un-hardcode the array length if we have the ::<> syntax proposed in https://github.com/noir-lang/noir/issues/2458
 fn get_some<Env>(generator: fn[Env]() -> Field) -> [Field; 5] {
-    [0,0,0,0,0].map(|_| generator())
+    [0, 0, 0, 0, 0].map(|_| generator())
 }
 
 fn test_fib() {
@@ -44,9 +44,9 @@ fn test_fib() {
 
 fn test_counter() {
     let counter = make_counter();
-    assert(counter()  == 1);
-    assert(counter()  == 2);
-    assert(counter()  == 3);
+    assert(counter() == 1);
+    assert(counter() == 2);
+    assert(counter() == 3);
 
     assert(get_some(counter) == [4, 5, 6, 7, 8]);
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/higher_order_fn_selector/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/higher_order_fn_selector/src/main.nr
index e1a13919f4c..d3fd4d5f94a 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/higher_order_fn_selector/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/higher_order_fn_selector/src/main.nr
@@ -1,4 +1,3 @@
-
 fn g(x: &mut Field) -> () {
     *x *= 2;
 }
@@ -8,11 +7,7 @@ fn h(x: &mut Field) -> () {
 }
 
 fn selector(flag: &mut bool) -> fn(&mut Field) -> () {
-    let my_func = if *flag {
-        g
-    } else {
-        h
-    };
+    let my_func = if *flag { g } else { h };
 
     // Flip the flag for the next function call
     *flag = !(*flag);
@@ -20,7 +15,6 @@ fn selector(flag: &mut bool) -> fn(&mut Field) -> () {
 }
 
 fn main() {
-    
     let mut flag: bool = true;
 
     let mut x: Field = 100;
@@ -34,5 +28,4 @@ fn main() {
     returned_func2(&mut y);
 
     assert(y == 300);
-
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/intrinsic_die/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/intrinsic_die/src/main.nr
index 08c5cce4034..aef6a13271b 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/intrinsic_die/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/intrinsic_die/src/main.nr
@@ -1,11 +1,9 @@
 use dep::std;
 
 // This test checks that we perform dead-instruction-elimination on intrinsic functions.
-
 fn main(x: Field) {
     let bytes = x.to_be_bytes(32);
-  
+
     let hash = std::hash::pedersen([x]);
     let _p1 = std::scalar_mul::fixed_base_embedded_curve(x, 0);
-
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/option/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/option/src/main.nr
index 22229014eef..1f879bd375f 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/option/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/option/src/main.nr
@@ -2,7 +2,6 @@ use dep::std::option::Option;
 
 fn main() {
     let ten = 10; // giving this a name, to ensure that the Option functions work with closures
-
     let none = Option::none();
     let some = Option::some(3);
 
diff --git a/tooling/nargo_cli/tests/compile_success_empty/regression_2099/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/regression_2099/src/main.nr
index b96e664dedf..ab74bd2c826 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/regression_2099/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/regression_2099/src/main.nr
@@ -11,11 +11,19 @@ use dep::std::ec::montcurve::curvegroup::Point as MG;
 
 fn main() {
     // Define Baby Jubjub (ERC-2494) parameters in affine representation
-    let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+    let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(
+            995203441582195749578291179787384436505546430278305826713579947235728471134, 5472060717959818805561601436314318772137091100104008585924551046643952123905
+        ));
 
     // Test addition
-    let p1_affine = Gaffine::new(17777552123799933955779906779655732241715742912184938656739573121738514868268, 2626589144620713026669568689430873010625803728049924121243784502389097019475);
-    let p2_affine = Gaffine::new(16540640123574156134436876038791482806971768689494387082833631921987005038935, 20819045374670962167435360035096875258406992893633759881276124905556507972311);      
+    let p1_affine = Gaffine::new(
+        17777552123799933955779906779655732241715742912184938656739573121738514868268, 
+        2626589144620713026669568689430873010625803728049924121243784502389097019475
+    );
+    let p2_affine = Gaffine::new(
+        16540640123574156134436876038791482806971768689494387082833631921987005038935, 
+        20819045374670962167435360035096875258406992893633759881276124905556507972311
+    );
     let _p3_affine = bjj_affine.add(p1_affine, p2_affine);
     
     // Test SWCurve equivalents of the above
@@ -25,13 +33,8 @@ fn main() {
     let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine);
     let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine);
 
-    let _p3_swcurve_affine_from_add = bjj_swcurve_affine.add(
-        p1_swcurve_affine,
-        p2_swcurve_affine
-    );
+    let _p3_swcurve_affine_from_add = bjj_swcurve_affine.add(p1_swcurve_affine, p2_swcurve_affine);
 
     // Check that these points are on the curve
-    assert(
-        bjj_swcurve_affine.contains(p1_swcurve_affine)
-    );            
+    assert(bjj_swcurve_affine.contains(p1_swcurve_affine));
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/ret_fn_ret_cl/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/ret_fn_ret_cl/src/main.nr
index a368dc58529..13ac6c8d764 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/ret_fn_ret_cl/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/ret_fn_ret_cl/src/main.nr
@@ -17,7 +17,6 @@ fn ret_fn() -> fn(Field) -> Field {
 //     };
 //     inner_closure
 // }
-
 fn ret_lambda() -> fn(Field) -> Field {
     let cl = |z: Field| -> Field {
         z + 1
@@ -31,7 +30,6 @@ fn main(x : Field) {
 
     // let result_closure = ret_closure();
     // assert(result_closure(x) == x + 1);
-
     let result_lambda = ret_lambda();
     assert(result_lambda(x) == x + 1);
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/simple_program_no_body/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/simple_program_no_body/src/main.nr
index b87f216b461..1c66955e126 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/simple_program_no_body/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/simple_program_no_body/src/main.nr
@@ -6,4 +6,4 @@
 //
 // This program will never fail since there are
 // no assertions being applied.
-fn main(_x : Field, _y : pub Field) {}
\ No newline at end of file
+fn main(_x : Field, _y : pub Field) {}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/simple_range/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/simple_range/src/main.nr
index 9a4b9033493..38f95d99f9b 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/simple_range/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/simple_range/src/main.nr
@@ -1,6 +1,6 @@
 // Tests a very simple program.
 // 
 // The features being tested is casting to an integer
-fn main(x : Field)  {
+fn main(x : Field) {
     let _z = x as u32;
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/specialization/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/specialization/src/main.nr
index 32102ad1437..9cd32e0f1eb 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/specialization/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/specialization/src/main.nr
@@ -9,7 +9,7 @@ impl Foo<u64> {
 }
 
 fn main() {
-    let f1: Foo<u32> = Foo{};
-    let f2: Foo<u64> = Foo{};
+    let f1: Foo<u32> = Foo {};
+    let f2: Foo<u64> = Foo {};
     assert(f1.foo() + f2.foo() == 3);
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/str_as_bytes/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/str_as_bytes/src/main.nr
index 6890b156b15..6fdd926ce7f 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/str_as_bytes/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/str_as_bytes/src/main.nr
@@ -2,17 +2,17 @@ use dep::std;
 fn main() {
     let a = "hello";
     let b = a.as_bytes();
-    assert(b[0]==104);
-    assert(b[1]==101);
-    assert(b[2]==108);
-    assert(b[3]==108);
-    assert(b[4]==111);
-    assert(b.len()==5);
+    assert(b[0] == 104);
+    assert(b[1] == 101);
+    assert(b[2] == 108);
+    assert(b[3] == 108);
+    assert(b[4] == 111);
+    assert(b.len() == 5);
     let mut c = a.as_bytes_vec();
-    assert(c.get(0)==104);
-    assert(c.get(1)==101);
-    assert(c.get(2)==108);
-    assert(c.get(3)==108);
-    assert(c.get(4)==111);
-    assert(c.len()==5);
+    assert(c.get(0) == 104);
+    assert(c.get(1) == 101);
+    assert(c.get(2) == 108);
+    assert(c.get(3) == 108);
+    assert(c.get(4) == 111);
+    assert(c.len() == 5);
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/to_bits/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/to_bits/src/main.nr
index 65ff9dcac01..5da3ca9e060 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/to_bits/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/to_bits/src/main.nr
@@ -1,4 +1,3 @@
-
 fn main() {
     let field = 1000;
     let be_bits = field.to_be_bits(16);
@@ -19,5 +18,4 @@ fn main() {
         let le_bit = le_bits_x[3-i];
         assert(be_bit == le_bit);
     }
-
 }
diff --git a/tooling/nargo_cli/tests/compile_success_empty/unconstrained_empty/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/unconstrained_empty/src/main.nr
index 6a3e59c5fed..5e5fb297236 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/unconstrained_empty/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/unconstrained_empty/src/main.nr
@@ -1,2 +1 @@
-unconstrained fn main() {
-}
+unconstrained fn main() {}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/unit/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/unit/src/main.nr
index 2cb1f7d7c66..603829ec6db 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/unit/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/unit/src/main.nr
@@ -9,6 +9,10 @@ fn main() {
 }
 
 fn f1() {}
-fn f2() { () }
+fn f2() {
+    ()
+}
 fn f3() -> () {}
-fn f4() -> () { () }
+fn f4() -> () {
+    ()
+}
diff --git a/tooling/nargo_cli/tests/compile_success_empty/unused_variables/src/main.nr b/tooling/nargo_cli/tests/compile_success_empty/unused_variables/src/main.nr
index d0ffa8a0d91..5c27340caca 100644
--- a/tooling/nargo_cli/tests/compile_success_empty/unused_variables/src/main.nr
+++ b/tooling/nargo_cli/tests/compile_success_empty/unused_variables/src/main.nr
@@ -1,3 +1 @@
-fn main(x : Field, y : pub Field) {
-
-}
\ No newline at end of file
+fn main(x : Field, y : pub Field) {}
diff --git a/tooling/nargo_cli/tests/execution_success/1327_concrete_in_generic/src/main.nr b/tooling/nargo_cli/tests/execution_success/1327_concrete_in_generic/src/main.nr
index 368d4811e45..5d139111c53 100644
--- a/tooling/nargo_cli/tests/execution_success/1327_concrete_in_generic/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/1327_concrete_in_generic/src/main.nr
@@ -58,9 +58,7 @@ fn d_method(input: D) -> Field {
 }
 
 fn get_d_method_interface() -> MethodInterface<D> {
-    MethodInterface {
-            some_method_on_t_d: d_method,
-        }
+    MethodInterface { some_method_on_t_d: d_method }
 }  
 
 // ---
diff --git a/tooling/nargo_cli/tests/execution_success/2_div/src/main.nr b/tooling/nargo_cli/tests/execution_success/2_div/src/main.nr
index ff0dee755cc..e16cc5be229 100644
--- a/tooling/nargo_cli/tests/execution_success/2_div/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/2_div/src/main.nr
@@ -2,6 +2,6 @@
 fn main(mut x: u32, y: u32, z: u32) {
     let a = x % y;
     assert(x / y == z);
-    assert(a == x - z*y);
+    assert(a == x - z * y);
     assert((50 as u64) % (9 as u64) == 5);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/3_add/src/main.nr b/tooling/nargo_cli/tests/execution_success/3_add/src/main.nr
index 2884415b81a..480348dc1cf 100644
--- a/tooling/nargo_cli/tests/execution_success/3_add/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/3_add/src/main.nr
@@ -4,5 +4,5 @@ fn main(mut x: u32, y: u32, z: u32) {
     assert(x == z);
 
     x *= 8;
-    assert(x>9);
+    assert(x > 9);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/6/src/main.nr b/tooling/nargo_cli/tests/execution_success/6/src/main.nr
index 8b350de16c1..152d3da40bd 100644
--- a/tooling/nargo_cli/tests/execution_success/6/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/6/src/main.nr
@@ -14,7 +14,7 @@ fn main(x: [u8; 5], result: pub [u8; 32]) {
     digest = std::hash::sha256(x);
     assert(digest == result);
 
-    let y = [12,45,78,41];
+    let y = [12, 45, 78, 41];
     let h = std::hash::mimc_bn254(y);
-   assert(h == 18226366069841799622585958305961373004333097209608110160936134895615261821931);
+    assert(h == 18226366069841799622585958305961373004333097209608110160936134895615261821931);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/7_function/src/main.nr b/tooling/nargo_cli/tests/execution_success/7_function/src/main.nr
index 8fd85fa31cf..32926171098 100644
--- a/tooling/nargo_cli/tests/execution_success/7_function/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/7_function/src/main.nr
@@ -49,7 +49,7 @@ fn test3(x: [u8; 3]) -> [u8; 3] {
 }
 
 fn test_multiple(x: u32, y: u32) -> (u32, u32) {
-    (y,x)
+    (y, x)
 }
 
 fn test_multiple2() -> my_struct {
@@ -71,11 +71,11 @@ struct my2 {
 }
 
 fn test_multiple4(s: my_struct) {
-    assert(s.a == s.b+2);
+    assert(s.a == s.b + 2);
 }
 
 fn test_multiple5(a: (u32, u32)) {
-    assert(a.0 == a.1+2);
+    assert(a.0 == a.1 + 2);
 }
 
 fn test_multiple6(a: my2, b: my_struct, c: (my2, my_struct)) {
@@ -93,20 +93,17 @@ fn bar() -> [Field; 1] {
 }
 
 fn main(x: u32 , y: u32 , a: Field, arr1: [u32; 9], arr2: [u32; 9]) {
-    let mut ss: my_struct = my_struct { b: x, a: x+2, };
+    let mut ss: my_struct = my_struct { b: x, a: x + 2 };
     test_multiple4(ss);
-    test_multiple5((ss.a,ss.b));
-    let my = my2 {
-        aa: ss,
-        bb: ss,
-    };
+    test_multiple5((ss.a, ss.b));
+    let my = my2 { aa: ss, bb: ss };
     ss.a = 61;
-    test_multiple6(my, ss, (my,ss));
+    test_multiple6(my, ss, (my, ss));
 
     let my_block = {
         let mut ab = f2(a);
         ab = ab + a;
-        (x,ab)
+        (x, ab)
     };
     assert(my_block.1 == 4);
 
diff --git a/tooling/nargo_cli/tests/execution_success/array_dynamic/src/main.nr b/tooling/nargo_cli/tests/execution_success/array_dynamic/src/main.nr
index 14b6f7d3b85..dd732f37e9b 100644
--- a/tooling/nargo_cli/tests/execution_success/array_dynamic/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/array_dynamic/src/main.nr
@@ -1,18 +1,18 @@
 fn main(x: [u32; 5], mut z: u32, t: u32, index: [Field;5], index2: [Field;5], offset: Field, sublen: Field) {
-    let idx = (z - 5*t - 5) as Field;
+    let idx = (z - 5 * t - 5) as Field;
     //dynamic array test
     dyn_array(x, idx, idx - 3); 
 
     //regression for issue 1283
     let mut s = 0;
-    let x3 = [246,159,32,176,8];
+    let x3 = [246, 159, 32, 176, 8];
     for i in 0..5 {
       s += x3[index[i]];
     }
-    assert(s!=0);
+    assert(s != 0);
 
     if 3 < (sublen as u32) {
-      assert(index[offset + 3] == index2[3]);
+        assert(index[offset + 3] == index2[3]);
     }
 }
 
diff --git a/tooling/nargo_cli/tests/execution_success/array_eq/src/main.nr b/tooling/nargo_cli/tests/execution_success/array_eq/src/main.nr
index d1771ed91a6..5bbd595898c 100644
--- a/tooling/nargo_cli/tests/execution_success/array_eq/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/array_eq/src/main.nr
@@ -1,4 +1,4 @@
 // Simple example of checking where two arrays are equal
 fn main(a: [Field; 32], b: [Field; 32]) {
-     assert(a == b);
+    assert(a == b);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/array_neq/src/main.nr b/tooling/nargo_cli/tests/execution_success/array_neq/src/main.nr
index be734dea368..a3e51dc5066 100644
--- a/tooling/nargo_cli/tests/execution_success/array_neq/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/array_neq/src/main.nr
@@ -1,4 +1,4 @@
 // Simple example of checking where two arrays are different
 fn main(a: [Field; 32], b: [Field; 32]) {
-     assert(a != b);
+    assert(a != b);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/bit_and/src/main.nr b/tooling/nargo_cli/tests/execution_success/bit_and/src/main.nr
index 35671abea63..8b5074d5a24 100644
--- a/tooling/nargo_cli/tests/execution_success/bit_and/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/bit_and/src/main.nr
@@ -3,7 +3,7 @@
 fn main(x : Field, y : Field) {
     let x_as_u8 = x as u8;
     let y_as_u8 = y as u8;
-    
+
     assert((x_as_u8 & y_as_u8) == x_as_u8);
 
     //bitwise and with 1 bit:
diff --git a/tooling/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr b/tooling/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr
index 209861e74fa..f46c7ea1ea8 100644
--- a/tooling/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/bit_shifts_comptime/src/main.nr
@@ -3,21 +3,21 @@ fn main(x: u64) {
     let three: u64 = 3;
 
 	// shifts on constant values
-	assert(two << 2 == 8);
-	assert((two << 3) / 8 == two);
-	assert((three >> 1) == 1);
+    assert(two << 2 == 8);
+    assert((two << 3) / 8 == two);
+    assert((three >> 1) == 1);
 
 	// shifts on runtime values
-	assert(x << 1 == 128);
-	assert(x >> 2 == 16);
+    assert(x << 1 == 128);
+    assert(x >> 2 == 16);
 
     regression_2250();
 }
 
 fn regression_2250() {
     let a: u1 = 1 >> 1;
-	assert(a == 0);
+    assert(a == 0);
 
     let b: u32 = 1 >> 32;
-	assert(b == 0);
+    assert(b == 0);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr b/tooling/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr
index f4d9c3916a6..b415a573ad5 100644
--- a/tooling/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/bit_shifts_runtime/src/main.nr
@@ -1,9 +1,9 @@
 fn main(x: u64, y: u64) {
 	// runtime shifts on compile-time known values
-	assert(64 << y == 128);
-	assert(64 >> y == 32);
+    assert(64 << y == 128);
+    assert(64 >> y == 32);
 
 	// runtime shifts on runtime values
-	assert(x << y == 128);
-	assert(x >> y == 32);
+    assert(x << y == 128);
+    assert(x >> y == 32);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_conditional/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_conditional/src/main.nr
index a3d92ab58e9..e77d4d9479e 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_conditional/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_conditional/src/main.nr
@@ -6,9 +6,5 @@ fn main(x: Field) {
 }
 
 unconstrained fn conditional(x : bool) -> Field {
-    if x {
-        4
-    }else {
-        5
-    }
+    if x { 4 } else { 5 }
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_keccak/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_keccak/src/main.nr
index 46c2a59f6b6..38258af0adf 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_keccak/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_keccak/src/main.nr
@@ -11,13 +11,13 @@ fn main(x: Field, result: [u8; 32]) {
     
     //#1399: variable meesage size
     let message_size = 4;
-    let hash_a = keccak256([1,2,3,4], message_size);
-    let hash_b = keccak256([1,2,3,4,0,0,0,0], message_size);
+    let hash_a = keccak256([1, 2, 3, 4], message_size);
+    let hash_b = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
 
     assert(hash_a == hash_b);
 
     let message_size_big = 8;
-    let hash_c = keccak256([1,2,3,4,0,0,0,0], message_size_big);
+    let hash_c = keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
 
     assert(hash_a != hash_c);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_nested_arrays/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_nested_arrays/src/main.nr
index e182585f5e5..d0a60ac0a58 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_nested_arrays/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_nested_arrays/src/main.nr
@@ -13,16 +13,16 @@ unconstrained fn access_nested(notes: [MyNote; 2], x: Field, y: Field) -> Field
 }
 
 unconstrained fn create_inside_brillig(x: Field, y: Field) {
-    let header = Header { params: [1, 2, 3]};
-    let note0 = MyNote { array: [1, 2], plain : 3, header };
-    let note1 = MyNote { array: [4, 5], plain : 6, header };
+    let header = Header { params: [1, 2, 3] };
+    let note0 = MyNote { array: [1, 2], plain: 3, header };
+    let note1 = MyNote { array: [4, 5], plain: 6, header };
     assert(access_nested([note0, note1], x, y) == (2 + 4 + 3 + 1));
 }
 
 fn main(x: Field, y: Field) {
-    let header = Header { params: [1, 2, 3]};
-    let note0 = MyNote { array: [1, 2], plain : 3, header };
-    let note1 = MyNote { array: [4, 5], plain : 6, header };
+    let header = Header { params: [1, 2, 3] };
+    let note0 = MyNote { array: [1, 2], plain: 3, header };
+    let note1 = MyNote { array: [4, 5], plain: 6, header };
 
     create_inside_brillig(x, y);
     assert(access_nested([note0, note1], x, y) == (2 + 4 + 3 + 1));
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_pedersen/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_pedersen/src/main.nr
index dfa10c96663..5aecf4fb84e 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_pedersen/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_pedersen/src/main.nr
@@ -9,7 +9,7 @@ unconstrained fn main(x: Field, y: Field, salt: Field, out_x: Field, out_y: Fiel
 
     assert(res_hash != res[0]);
 
-    let raw_data = [x,y];
+    let raw_data = [x, y];
     let mut state = 0;
     for i in 0..(2 as u32) {
         state = state * 8 + raw_data[i];
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_recursion/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_recursion/src/main.nr
index 43d1034fbbf..ebfc48c9198 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_recursion/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_recursion/src/main.nr
@@ -6,9 +6,5 @@ fn main(x: u32) {
 }
 
 unconstrained fn fibonacci(x : u32) -> u32 {
-    if x <= 1 {
-        x
-    } else {
-        fibonacci(x - 1) + fibonacci(x - 2)
-    }
+    if x <= 1 { x } else { fibonacci(x - 1) + fibonacci(x - 2) }
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_references/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_references/src/main.nr
index 46372940bc8..4118e4216a1 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_references/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_references/src/main.nr
@@ -18,12 +18,7 @@ unconstrained fn main(mut x: Field) {
     assert(**nested_allocations.y == 1);
 
     // Test nested struct allocations with a mutable reference to an array.
-    let mut c = C {
-        foo: 0,
-        bar: &mut C2 {
-            array: &mut [1, 2],
-        },
-    };
+    let mut c = C { foo: 0, bar: &mut C2 { array: &mut [1, 2] } };
     *c.bar.array = [3, 4];
     let arr: [Field; 2] = *c.bar.array;
     assert(arr[0] == 3);
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_scalar_mul/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_scalar_mul/src/main.nr
index b95a8d4ef4a..c85bc433a76 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_scalar_mul/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_scalar_mul/src/main.nr
@@ -15,8 +15,8 @@ unconstrained fn main(
           priv_key = b;
           pub_x = b_pub_x;
           pub_y = b_pub_y;
-     }
+    }
     let res = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
-     assert(res[0] == pub_x);
-     assert(res[1] == pub_y);
+    assert(res[0] == pub_x);
+    assert(res[1] == pub_y);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_schnorr/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_schnorr/src/main.nr
index 4212839601f..f30299b8a7b 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_schnorr/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_schnorr/src/main.nr
@@ -12,10 +12,10 @@ unconstrained fn main(message: [u8; 10], message_field: Field, pub_key_x: Field,
     // Is there ever a situation where someone would want 
     // to ensure that a signature was invalid?
     // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x,pub_key_y,signature, message_field_bytes);
+    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message_field_bytes);
     assert(valid_signature);
 
     // Check that passing an array as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x,pub_key_y,signature, message);
+    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
     assert(valid_signature);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/brillig_to_bytes_integration/src/main.nr b/tooling/nargo_cli/tests/execution_success/brillig_to_bytes_integration/src/main.nr
index 775d1e512d9..bc1b96a40b5 100644
--- a/tooling/nargo_cli/tests/execution_success/brillig_to_bytes_integration/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/brillig_to_bytes_integration/src/main.nr
@@ -6,7 +6,7 @@ unconstrained fn main(x : Field, _y: Field) {
     let be_byte_array = y.to_be_bytes(31);
     // The result of this byte array will be little-endian
     let le_byte_array = x.to_le_bytes(31);
-    
+
     assert(le_byte_array[0] == 60);
     assert(le_byte_array[0] == be_byte_array[30]);
     assert(le_byte_array[1] == be_byte_array[29]);
diff --git a/tooling/nargo_cli/tests/execution_success/conditional_1/src/main.nr b/tooling/nargo_cli/tests/execution_success/conditional_1/src/main.nr
index 176106ba890..bd29f135082 100644
--- a/tooling/nargo_cli/tests/execution_success/conditional_1/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/conditional_1/src/main.nr
@@ -40,7 +40,7 @@ fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {
   
 
     //Test case for conditional with arrays from function parameters
-    let b = sort([1,2,3,4]);
+    let b = sort([1, 2, 3, 4]);
     assert(b[0] == 1);
 
     if a == 0 {
@@ -51,7 +51,7 @@ fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {
         c[0] = 1;
         c[1] = c[2] / a + 11 % a;
         let f1 = a as Field;
-        assert(10/f1 != 0);
+        assert(10 / f1 != 0);
     }
     assert(c[0] == 3);
 
diff --git a/tooling/nargo_cli/tests/execution_success/conditional_2/src/main.nr b/tooling/nargo_cli/tests/execution_success/conditional_2/src/main.nr
index 70237d4b638..c4d60d8b999 100644
--- a/tooling/nargo_cli/tests/execution_success/conditional_2/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/conditional_2/src/main.nr
@@ -11,7 +11,7 @@ fn test3 (x: u8) {
 }
 
 fn test4() -> [u32; 4] {
-    let b: [u32; 4] = [1,2,3,4];
+    let b: [u32; 4] = [1, 2, 3, 4];
     b
 }
 
diff --git a/tooling/nargo_cli/tests/execution_success/conditional_regression_421/src/main.nr b/tooling/nargo_cli/tests/execution_success/conditional_regression_421/src/main.nr
index 60052c20610..5789afb76db 100644
--- a/tooling/nargo_cli/tests/execution_success/conditional_regression_421/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/conditional_regression_421/src/main.nr
@@ -2,13 +2,9 @@ fn main(a: u32, mut c: [u32; 4]) {
     //Issue reported in #421
     if a == c[0] {
         assert(c[0] == 0);
-    } else {
-        if a == c[1] {
-            assert(c[1] == 0);
-        } else  {
-            if a == c[2] {
-                assert(c[2] == 0);
-            }
-        }
+    } else if a == c[1] {
+        assert(c[1] == 0);
+    } else if a == c[2] {
+        assert(c[2] == 0);
     }
 }
diff --git a/tooling/nargo_cli/tests/execution_success/conditional_regression_661/src/main.nr b/tooling/nargo_cli/tests/execution_success/conditional_regression_661/src/main.nr
index efdc1ddbce4..5d8734897d7 100644
--- a/tooling/nargo_cli/tests/execution_success/conditional_regression_661/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/conditional_regression_661/src/main.nr
@@ -21,7 +21,7 @@ fn issue_661_foo(array: [u32;4], b:u32) ->[u32;1] {
 }
 
 fn issue_661_bar(a : [u32;4]) ->[u32;4] {
-    let mut b: [u32; 4] = [0;4];
+    let mut b: [u32; 4] = [0; 4];
     b[0]=a[0]+1;
     b
 }
diff --git a/tooling/nargo_cli/tests/execution_success/conditional_regression_short_circuit/src/main.nr b/tooling/nargo_cli/tests/execution_success/conditional_regression_short_circuit/src/main.nr
index 57387ed5052..b119619990e 100644
--- a/tooling/nargo_cli/tests/execution_success/conditional_regression_short_circuit/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/conditional_regression_short_circuit/src/main.nr
@@ -33,6 +33,6 @@ fn call_intrinsic(x: [u8; 5], result: [u8; 32]) {
 }
 
 fn test4() -> [u32; 4] {
-    let b: [u32; 4] = [1,2,3,4];
+    let b: [u32; 4] = [1, 2, 3, 4];
     b
 }
diff --git a/tooling/nargo_cli/tests/execution_success/double_verify_proof/src/main.nr b/tooling/nargo_cli/tests/execution_success/double_verify_proof/src/main.nr
index c679730e3c0..92e8326a895 100644
--- a/tooling/nargo_cli/tests/execution_success/double_verify_proof/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/double_verify_proof/src/main.nr
@@ -9,19 +9,11 @@ fn main(
     proof_b : [Field; 94],
 ) -> pub [Field; 16] {
     let output_aggregation_object_a = std::verify_proof(
-        verification_key.as_slice(), 
-        proof.as_slice(), 
-        public_inputs.as_slice(), 
-        key_hash, 
-        input_aggregation_object
+        verification_key.as_slice(), proof.as_slice(), public_inputs.as_slice(), key_hash, input_aggregation_object
     );
 
     let output_aggregation_object = std::verify_proof(
-        verification_key.as_slice(),
-        proof_b.as_slice(),
-        public_inputs.as_slice(),
-        key_hash,
-        output_aggregation_object_a
+        verification_key.as_slice(), proof_b.as_slice(), public_inputs.as_slice(), key_hash, output_aggregation_object_a
     );
 
     let mut output = [0; 16];
diff --git a/tooling/nargo_cli/tests/execution_success/ecdsa_secp256k1/src/main.nr b/tooling/nargo_cli/tests/execution_success/ecdsa_secp256k1/src/main.nr
index 5af8008f291..38a6ebd13e5 100644
--- a/tooling/nargo_cli/tests/execution_success/ecdsa_secp256k1/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/ecdsa_secp256k1/src/main.nr
@@ -3,8 +3,8 @@ use dep::std;
 fn main(message : [u8;38],hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
      // Hash the message, since secp256k1 expects a hashed_message
     let expected = std::hash::sha256(message);
-     assert(hashed_message == expected);
+    assert(hashed_message == expected);
 
     let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
-     assert(valid_signature);
+    assert(valid_signature);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/ecdsa_secp256r1/src/main.nr b/tooling/nargo_cli/tests/execution_success/ecdsa_secp256r1/src/main.nr
index eda78cd81a6..840a401f109 100644
--- a/tooling/nargo_cli/tests/execution_success/ecdsa_secp256r1/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/ecdsa_secp256r1/src/main.nr
@@ -2,5 +2,5 @@ use dep::std;
 
 fn main(hashed_message : [u8;32], pub_key_x : [u8;32], pub_key_y : [u8;32], signature : [u8;64]) {
     let valid_signature = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
-     assert(valid_signature);
+    assert(valid_signature);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/eddsa/src/main.nr b/tooling/nargo_cli/tests/execution_success/eddsa/src/main.nr
index 870a20fe01a..f82b3224c3d 100644
--- a/tooling/nargo_cli/tests/execution_success/eddsa/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/eddsa/src/main.nr
@@ -37,7 +37,7 @@ fn main(msg: pub Field, _priv_key_a: Field, _priv_key_b: Field) {
         // ]);
 
         // let s_a = (r_a + _priv_key_a * h_a) % bjj.suborder; // modulus computed manually
-        let s_a =  30333430637424319196043722294837632681219980330991241982145549329256671548;
+        let s_a = 30333430637424319196043722294837632681219980330991241982145549329256671548;
         // let s_b = (r_b + _priv_key_b * h_b) % bjj.suborder; // modulus computed manually
         let s_b = 1646085314320208098241070054368798527940102577261034947654839408482102287019;
 
diff --git a/tooling/nargo_cli/tests/execution_success/field_attribute/src/main.nr b/tooling/nargo_cli/tests/execution_success/field_attribute/src/main.nr
index d6d71781899..dda83db40de 100644
--- a/tooling/nargo_cli/tests/execution_success/field_attribute/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/field_attribute/src/main.nr
@@ -16,4 +16,4 @@ fn foo() -> u32 {
 #[field(bls12_381)]
 fn foo() -> u32 {
     3
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/execution_success/global_consts/src/main.nr b/tooling/nargo_cli/tests/execution_success/global_consts/src/main.nr
index 0c3a4fcd771..07d88cb2049 100644
--- a/tooling/nargo_cli/tests/execution_success/global_consts/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/global_consts/src/main.nr
@@ -27,10 +27,10 @@ fn main(a: [Field; M + N - N], b: [Field; 30 + N / 2], c : pub [Field; foo::MAGI
           assert(test_struct.y[i] != NESTED[1][0].v);
      }
 
-     assert(N != M);
+    assert(N != M);
 
     let expected: u32 = 42;
-     assert(foo::TYPE_INFERRED == expected);
+    assert(foo::TYPE_INFERRED == expected);
 
     let mut y = 5;
     let mut x = M;
@@ -40,30 +40,30 @@ fn main(a: [Field; M + N - N], b: [Field; 30 + N / 2], c : pub [Field; foo::MAGI
           
           y = i;
      }
-     assert(y == 24);
-     assert(x == 10);
+    assert(y == 24);
+    assert(x == 10);
 
     let q = multiplyByM(3);
-     assert(q == 96);
+    assert(q == 96);
 
     arrays_neq(a, b);
 
     let t: [Field; T_LEN] = [N, M];
-     assert(t[1] == 32);
+    assert(t[1] == 32);
 
-     assert(15 == mysubmodule::my_helper());
+    assert(15 == mysubmodule::my_helper());
 
     let add_submodules_N = mysubmodule::N + foo::bar::N;
-     assert(15 == add_submodules_N);
+    assert(15 == add_submodules_N);
     let add_from_bar_N = mysubmodule::N + foo::bar::from_bar(1);
-     assert(15 == add_from_bar_N);
+    assert(15 == add_from_bar_N);
 
      // Example showing an array filled with (mysubmodule::N + 2) 0's
     let sugared = [0; mysubmodule::N + 2];
-     assert(sugared[mysubmodule::N + 1] == 0);
+    assert(sugared[mysubmodule::N + 1] == 0);
 
     let arr: [Field; mysubmodule::N] = [N; 10];
-     assert((arr[0] == 5) & (arr[9] == 5));
+    assert((arr[0] == 5) & (arr[9] == 5));
 
     foo::from_foo(d);
     baz::from_baz(c);
@@ -74,7 +74,7 @@ fn multiplyByM(x: Field) -> Field {
 }
 
 fn arrays_neq(a: [Field; M], b: [Field; M]) {
-     assert(a != b);
+    assert(a != b);
 }
 
 mod mysubmodule {
diff --git a/tooling/nargo_cli/tests/execution_success/if_else_chain/src/main.nr b/tooling/nargo_cli/tests/execution_success/if_else_chain/src/main.nr
index 9fd5fbfd3d3..2705d5b3111 100644
--- a/tooling/nargo_cli/tests/execution_success/if_else_chain/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/if_else_chain/src/main.nr
@@ -9,7 +9,7 @@ fn main(a: u32, mut c: [u32; 4]) {
         // expect to match this case
         assert(c[3] == 0);
     } else {
-       assert(c[0] == 10);
+        assert(c[0] == 10);
     }
 }
 
diff --git a/tooling/nargo_cli/tests/execution_success/keccak256/src/main.nr b/tooling/nargo_cli/tests/execution_success/keccak256/src/main.nr
index 9bca6a7c1bf..511d668bc3d 100644
--- a/tooling/nargo_cli/tests/execution_success/keccak256/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/keccak256/src/main.nr
@@ -10,13 +10,13 @@ fn main(x: Field, result: [u8; 32]) {
     
     //#1399: variable meesage size
     let message_size = 4;
-    let hash_a = std::hash::keccak256([1,2,3,4], message_size);
-    let hash_b = std::hash::keccak256([1,2,3,4,0,0,0,0], message_size);
+    let hash_a = std::hash::keccak256([1, 2, 3, 4], message_size);
+    let hash_b = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size);
 
     assert(hash_a == hash_b);
 
     let message_size_big = 8;
-    let hash_c = std::hash::keccak256([1,2,3,4,0,0,0,0], message_size_big);
+    let hash_c = std::hash::keccak256([1, 2, 3, 4, 0, 0, 0, 0], message_size_big);
 
     assert(hash_a != hash_c);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/mock_oracle/src/main.nr b/tooling/nargo_cli/tests/execution_success/mock_oracle/src/main.nr
index 07553f05d6c..90fca7993cc 100644
--- a/tooling/nargo_cli/tests/execution_success/mock_oracle/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/mock_oracle/src/main.nr
@@ -9,12 +9,9 @@ struct Point {
 unconstrained fn foo_oracle(_point: Point, _array: [Field; 4]) -> Field {}
 
 unconstrained fn main() {
-    let array = [1,2,3,4];
-    let another_array = [4,3,2,1];
-    let point = Point {
-        x: 14,
-        y: 27,
-    };
+    let array = [1, 2, 3, 4];
+    let another_array = [4, 3, 2, 1];
+    let point = Point { x: 14, y: 27 };
 
     OracleMock::mock("foo").returns(42).times(1);
     let mock = OracleMock::mock("foo").returns(0);
diff --git a/tooling/nargo_cli/tests/execution_success/nested_array_dynamic/src/main.nr b/tooling/nargo_cli/tests/execution_success/nested_array_dynamic/src/main.nr
index 5538c08d778..cd10b5e7347 100644
--- a/tooling/nargo_cli/tests/execution_success/nested_array_dynamic/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/nested_array_dynamic/src/main.nr
@@ -38,7 +38,7 @@ fn main(mut x : [Foo; 4], y : pub Field) {
         x[y - 1].b = [100, 101, 102];
     }
     assert(x[2].b == [100, 101, 102]);
-    
+
     assert(x[y - 3].bar.inner == [100, 101, 102]);
     assert(x[y - 2].bar.inner == [103, 104, 105]);
     assert(x[y - 1].bar.inner == [106, 107, 108]);
@@ -52,7 +52,7 @@ fn main(mut x : [Foo; 4], y : pub Field) {
     assert(foo_parents[y - 3].foos[y - 2].b == [5, 6, 21]);
     assert(foo_parents[y - 3].foos[y - 1].b == [100, 101, 102]);
     assert(foo_parents[y - 3].foos[y].b == [11, 12, 23]);
-    
+
     assert(foo_parents[y - 3].foos[y].a == 50);
 
     assert(foo_parents[1].foos[1].b == [5, 6, 21]);
@@ -74,6 +74,5 @@ fn main(mut x : [Foo; 4], y : pub Field) {
     // Set a dynamic array value
     foo_parents[y - 2].foos[y - 3].b = foo_parents[y - 2].foos[y - 2].b;
     assert(foo_parents[1].foos[0].b == [20, 19, 5000]);
-
 }
 
diff --git a/tooling/nargo_cli/tests/execution_success/nested_arrays_from_brillig/src/main.nr b/tooling/nargo_cli/tests/execution_success/nested_arrays_from_brillig/src/main.nr
index 46c4ebe938e..1bcbd7d5421 100644
--- a/tooling/nargo_cli/tests/execution_success/nested_arrays_from_brillig/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/nested_arrays_from_brillig/src/main.nr
@@ -13,9 +13,9 @@ fn access_nested(notes: [MyNote; 2]) -> Field {
 }
 
 unconstrained fn create_inside_brillig(values: [Field; 6]) -> [MyNote; 2] {
-    let header = Header { params: [values[0], values[1], values[2]]};
-    let note0 = MyNote { array: [values[0], values[1]], plain : values[2], header };
-    let note1 = MyNote { array: [values[3], values[4]], plain : values[5], header };
+    let header = Header { params: [values[0], values[1], values[2]] };
+    let note0 = MyNote { array: [values[0], values[1]], plain: values[2], header };
+    let note1 = MyNote { array: [values[3], values[4]], plain: values[5], header };
     [note0, note1]
 }
 
diff --git a/tooling/nargo_cli/tests/execution_success/nested_slice_dynamic/src/main.nr b/tooling/nargo_cli/tests/execution_success/nested_slice_dynamic/src/main.nr
index a2de5141786..2d7c52da495 100644
--- a/tooling/nargo_cli/tests/execution_success/nested_slice_dynamic/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/nested_slice_dynamic/src/main.nr
@@ -41,7 +41,7 @@ fn main(y :  Field) {
         x[y - 1].b = [100, 101, 102];
     }
     assert(x[2].b == [100, 101, 102]);
-    
+
     assert(x[y - 3].bar.inner == [100, 101, 102]);
     assert(x[y - 2].bar.inner == [103, 104, 105]);
     assert(x[y - 1].bar.inner == [106, 107, 108]);
diff --git a/tooling/nargo_cli/tests/execution_success/pedersen_check/src/main.nr b/tooling/nargo_cli/tests/execution_success/pedersen_check/src/main.nr
index 8d3460de98f..e5e8c740ea9 100644
--- a/tooling/nargo_cli/tests/execution_success/pedersen_check/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/pedersen_check/src/main.nr
@@ -9,7 +9,7 @@ fn main(x: Field, y: Field, salt: Field, out_x: Field, out_y: Field, out_hash: F
 
     assert(res_hash != res[0]);
 
-    let raw_data = [x,y];
+    let raw_data = [x, y];
     let mut state = 0;
     for i in 0..2 {
         state = state * 8 + raw_data[i];
diff --git a/tooling/nargo_cli/tests/execution_success/poseidonsponge_x5_254/src/main.nr b/tooling/nargo_cli/tests/execution_success/poseidonsponge_x5_254/src/main.nr
index 6d75dcccc66..910a17c8c89 100644
--- a/tooling/nargo_cli/tests/execution_success/poseidonsponge_x5_254/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/poseidonsponge_x5_254/src/main.nr
@@ -3,6 +3,6 @@ use dep::std::hash::poseidon;
 fn main(x: [Field; 7]) {
     // Test optimized sponge
     let result = poseidon::bn254::sponge(x);
-    
+
     assert(result == 0x080ae1669d62f0197190573d4a325bfb8d8fc201ce3127cbac0c47a7ac81ac48);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/references/src/main.nr b/tooling/nargo_cli/tests/execution_success/references/src/main.nr
index 5265519f2a8..33fe69dc96e 100644
--- a/tooling/nargo_cli/tests/execution_success/references/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/references/src/main.nr
@@ -22,12 +22,7 @@ fn main(mut x: Field) {
     assert(**nested_allocations.y == 1);
 
     // Test nested struct allocations with a mutable reference to an array.
-    let mut c = C {
-        foo: 0,
-        bar: &mut C2 {
-            array: &mut [1, 2],
-        },
-    };
+    let mut c = C { foo: 0, bar: &mut C2 { array: &mut [1, 2] } };
     *c.bar.array = [3, 4];
     assert(*c.bar.array == [3, 4]);
 
@@ -135,15 +130,14 @@ fn regression_2218(x: Field, y: Field) -> Field {
         if x != 20 {
             *q1 = 10;
             *q2 = 2; // now we'd expect q1 == q2 == 2
-
-            assert(*q1 == 2);  
+            assert(*q1 == 2);
         } else {
             *q2 = 15;
             assert(*q1 == 15);
         }
     } else {
         *q2 = 20;
-        assert(*q1 == 20);  
+        assert(*q1 == 20);
     }
     // Have to assign value to return it
     let value = *q1;
@@ -232,7 +226,7 @@ fn regression_2218_loop(x: Field, y: Field) {
         }
     } else {
         *q2 = 20;
-        assert(*q1 == 20);  
+        assert(*q1 == 20);
     }
     assert(*q1 == 2);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/regression/src/main.nr b/tooling/nargo_cli/tests/execution_success/regression/src/main.nr
index 010468a450a..f8ac3823e08 100644
--- a/tooling/nargo_cli/tests/execution_success/regression/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/regression/src/main.nr
@@ -1,7 +1,7 @@
 global NIBBLE_LENGTH: Field = 16;
 
 fn compact_decode<N>(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Field) {
-    assert(2*input.len() as u64 <= NIBBLE_LENGTH as u64);
+    assert(2 * input.len() as u64 <= NIBBLE_LENGTH as u64);
     assert(length as u64 <= input.len() as u64);
 
     let mut nibble = [0 as u4; NIBBLE_LENGTH];
@@ -9,8 +9,7 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Fie
     let first_nibble = (input[0] >> 4) as u4;
     let parity = first_nibble as u1;
 
-    if parity == 1
-    {
+    if parity == 1 {
 	    nibble[0] = (input[0] & 0x0f) as u4;
 	    for i in 1..input.len()
 	    {
@@ -21,9 +20,7 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Fie
 	         	nibble[2*i] = (x & 0x0f) as u4;
  	        }
 	    }
-    }
-    else
-    {
+    } else {
 	    for i in 0..2
 	    {
  	        if (i as u64) < length as u64 - 1
@@ -35,7 +32,7 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Fie
 	    }
     }
 
-    let out = (nibble, 2*length + (parity as Field) - 2);
+    let out = (nibble, 2 * length + (parity as Field) - 2);
 
     out
 }
@@ -43,30 +40,24 @@ fn compact_decode<N>(input: [u8; N], length: Field) -> ([u4; NIBBLE_LENGTH], Fie
 fn enc<N>(value: [u8; N], value_length: Field) -> ([u8; 32], Field) {
     assert(value.len() as u8 >= value_length as u8);
     let mut out_value = [0; 32];
-    if value_length == 0
-    {
-    	let out = (out_value, value_length);
-		out
-    }
-    else { if value_length as u8 < 31
-    {
+    if value_length == 0 {
+        let out = (out_value, value_length);
+        out
+    } else if value_length as u8 < 31 {
 	out_value[0] = 0x80 + value_length as u8;
 	
 		for i in 1..value.len()
 		{
 			out_value[i] = value[i-1];
 		}
-		
-		let out = (out_value, value_length + 1);
 
-	out
-    }
-    else
-    {
-		let out = (out_value, 32);
-		out
+        let out = (out_value, value_length + 1);
+
+        out
+    } else {
+        let out = (out_value, 32);
+        out
     }
-	}
 }
 
 fn bitshift_literal_0() -> u64 {
@@ -90,17 +81,21 @@ fn bitshift_variable(idx: u64) -> u64 {
 
 fn main(x: [u8; 5], z: Field) {
     //Issue 1144
-    let (nib, len) = compact_decode(x,z);
-	assert(len == 5);
-	assert([nib[0], nib[1], nib[2], nib[3], nib[4]] == [15, 1, 12, 11, 8]);
+    let (nib, len) = compact_decode(x, z);
+    assert(len == 5);
+    assert([nib[0], nib[1], nib[2], nib[3], nib[4]] == [15, 1, 12, 11, 8]);
 
 	// Issue 1169
-    let val1 = [0xb8,0x8f,0x61,0xe6,0xfb,0xda,0x83,0xfb,0xff,0xfa,0xbe,0x36,0x41,0x12,0x13,0x74,0x80,0x39,0x80,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00];
+    let val1 = [0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12, 0x13,
+        0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00];
     let val1_length = 20;
 
-    let enc_val1 = enc(val1,val1_length);
+    let enc_val1 = enc(val1, val1_length);
 
-    assert(enc_val1.0 == [0x94,0xb8,0x8f,0x61,0xe6,0xfb,0xda,0x83,0xfb,0xff,0xfa,0xbe,0x36,0x41,0x12,0x13,0x74,0x80,0x39,0x80,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]);
+    assert(enc_val1.0 == [0x94, 0xb8, 0x8f, 0x61, 0xe6, 0xfb, 0xda, 0x83, 0xfb, 0xff, 0xfa, 0xbe, 0x36, 0x41, 0x12,
+        0x13, 0x74, 0x80, 0x39, 0x80, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00]);
     assert(enc_val1.1 == 21);
 
 	// Issue 2399
diff --git a/tooling/nargo_cli/tests/execution_success/regression_mem_op_predicate/src/main.nr b/tooling/nargo_cli/tests/execution_success/regression_mem_op_predicate/src/main.nr
index 368ca50397f..2592d02ec2e 100644
--- a/tooling/nargo_cli/tests/execution_success/regression_mem_op_predicate/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/regression_mem_op_predicate/src/main.nr
@@ -1,8 +1,8 @@
 fn main(mut x: [u32; 5], idx: Field) {
   // We should not hit out of bounds here as we have a predicate
   // that should not be hit
-    if idx as u32 < 3 {    
+    if idx as u32 < 3 {
     x[idx] = 10;
-  }
-  assert(x[4] == 111);
+    }
+    assert(x[4] == 111);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/scalar_mul/src/main.nr b/tooling/nargo_cli/tests/execution_success/scalar_mul/src/main.nr
index 87641b407d6..f62496d61d5 100644
--- a/tooling/nargo_cli/tests/execution_success/scalar_mul/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/scalar_mul/src/main.nr
@@ -15,8 +15,8 @@ fn main(
           priv_key = b;
           pub_x = b_pub_x;
           pub_y = b_pub_y;
-     }
+    }
     let res = std::scalar_mul::fixed_base_embedded_curve(priv_key, 0);
-     assert(res[0] == pub_x);
-     assert(res[1] == pub_y);
+    assert(res[0] == pub_x);
+    assert(res[1] == pub_y);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/schnorr/src/main.nr b/tooling/nargo_cli/tests/execution_success/schnorr/src/main.nr
index 3c8881b2f39..f974027f1cf 100644
--- a/tooling/nargo_cli/tests/execution_success/schnorr/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/schnorr/src/main.nr
@@ -12,10 +12,10 @@ fn main(message: [u8; 10], message_field: Field, pub_key_x: Field, pub_key_y: Fi
     // Is there ever a situation where someone would want 
     // to ensure that a signature was invalid?
     // Check that passing a slice as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x,pub_key_y,signature, message_field_bytes);
+    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message_field_bytes);
     assert(valid_signature);
 
     // Check that passing an array as the message is valid
-    let valid_signature = std::schnorr::verify_signature(pub_key_x,pub_key_y,signature, message);
+    let valid_signature = std::schnorr::verify_signature(pub_key_x, pub_key_y, signature, message);
     assert(valid_signature);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/sha2_blocks/src/main.nr b/tooling/nargo_cli/tests/execution_success/sha2_blocks/src/main.nr
index 52891d18de2..a491530dd7d 100644
--- a/tooling/nargo_cli/tests/execution_success/sha2_blocks/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/sha2_blocks/src/main.nr
@@ -4,18 +4,31 @@ use dep::std;
 fn main(x: [u8; 3], result256: [u8; 32], result512: [u8; 64]) {
 	// One-block tests.
     let mut digest256 = std::sha256::digest(x);
-	assert(digest256 == result256);
+    assert(digest256 == result256);
 
     let mut digest512 = std::sha512::digest(x);
-	assert(digest512 == result512);
+    assert(digest512 == result512);
 
 	// Two-block SHA256 test. Taken from https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA256.pdf
-    let y: [u8; 56] = [97,98,99,100,98,99,100,101,99,100,101,102,100,101,102,103,101,102,103,104,102,103,104,105,103,104,105,106,104,105,106,107,105,106,107,108,106,107,108,109,107,108,109,110,108,109,110,111,109,110,111,112,110,111,112,113]; // "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+    let y: [u8; 56] = [97, 98, 99, 100, 98, 99, 100, 101, 99, 100, 101, 102, 100, 101, 102, 103, 101, 102, 103,
+        104, 102, 103, 104, 105, 103, 104, 105, 106, 104, 105, 106, 107, 105, 106, 107, 108, 106,
+        107, 108, 109, 107, 108, 109, 110, 108, 109, 110, 111, 109, 110, 111, 112, 110, 111, 112,
+        113]; // "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
 	digest256 = std::sha256::digest(y);
-	assert(digest256 == [36,141,106,97,210,6,56,184,229,192,38,147,12,62,96,57,163,60,228,89,100,255,33,103,246,236,237,212,25,219,6,193]);
+    assert(digest256 == [36, 141, 106, 97, 210, 6, 56, 184, 229, 192, 38, 147, 12, 62, 96, 57, 163, 60, 228, 89, 100,
+        255, 33, 103, 246, 236, 237, 212, 25, 219, 6, 193]);
 
 	// Two-block SHA256 test. Taken from https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Standards-and-Guidelines/documents/examples/SHA512.pdf
-    let z: [u8; 112] = [97,98,99,100,101,102,103,104,98,99,100,101,102,103,104,105,99,100,101,102,103,104,105,106,100,101,102,103,104,105,106,107,101,102,103,104,105,106,107,108,102,103,104,105,106,107,108,109,103,104,105,106,107,108,109,110,104,105,106,107,108,109,110,111,105,106,107,108,109,110,111,112,106,107,108,109,110,111,112,113,107,108,109,110,111,112,113,114,108,109,110,111,112,113,114,115,109,110,111,112,113,114,115,116,110,111,112,113,114,115,116,117]; // "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
+    let z: [u8; 112] = [97, 98, 99, 100, 101, 102, 103, 104, 98, 99, 100, 101, 102, 103, 104, 105, 99, 100, 101,
+        102, 103, 104, 105, 106, 100, 101, 102, 103, 104, 105, 106, 107, 101, 102, 103, 104, 105,
+        106, 107, 108, 102, 103, 104, 105, 106, 107, 108, 109, 103, 104, 105, 106, 107, 108, 109,
+        110, 104, 105, 106, 107, 108, 109, 110, 111, 105, 106, 107, 108, 109, 110, 111, 112, 106,
+        107, 108, 109, 110, 111, 112, 113, 107, 108, 109, 110, 111, 112, 113, 114, 108, 109, 110,
+        111, 112, 113, 114, 115, 109, 110, 111, 112, 113, 114, 115, 116, 110, 111, 112, 113, 114,
+        115, 116, 117]; // "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
 	digest512 = std::sha512::digest(z);
-	assert(digest512 == [142,149,155,117,218,227,19,218,140,244,247,40,20,252,20,63,143,119,121,198,235,159,127,161,114,153,174,173,182,136,144,24,80,29,40,158,73,0,247,228,51,27,153,222,196,181,67,58,199,211,41,238,182,221,38,84,94,150,229,91,135,75,233,9]);
+    assert(digest512 == [142, 149, 155, 117, 218, 227, 19, 218, 140, 244, 247, 40, 20, 252, 20, 63, 143, 119, 121,
+        198, 235, 159, 127, 161, 114, 153, 174, 173, 182, 136, 144, 24, 80, 29, 40, 158, 73, 0, 247,
+        228, 51, 27, 153, 222, 196, 181, 67, 58, 199, 211, 41, 238, 182, 221, 38, 84, 94, 150, 229,
+        91, 135, 75, 233, 9]);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/sha2_byte/src/main.nr b/tooling/nargo_cli/tests/execution_success/sha2_byte/src/main.nr
index 6470ccd8379..fa8ddfbdf69 100644
--- a/tooling/nargo_cli/tests/execution_success/sha2_byte/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/sha2_byte/src/main.nr
@@ -3,8 +3,8 @@ use dep::std;
 
 fn main(x: Field, result256: [u8; 32], result512: [u8; 64]) {
     let digest256 = std::sha256::digest([x as u8]);
-	assert(digest256 == result256);
+    assert(digest256 == result256);
 
     let digest512 = std::sha512::digest([x as u8]);
-	assert(digest512 == result512);
+    assert(digest512 == result512);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/simple_2d_array/src/main.nr b/tooling/nargo_cli/tests/execution_success/simple_2d_array/src/main.nr
index c098a679a3b..2ecdd4bc15f 100644
--- a/tooling/nargo_cli/tests/execution_success/simple_2d_array/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/simple_2d_array/src/main.nr
@@ -3,6 +3,6 @@ fn main(x: Field, y: Field, array_input: [[Field; 2]; 2]) {
     assert(array_input[0][0] == x);
     assert(array_input[0][1] == y);
 
-    let arr: [[Field; 2]; 1] = [[3,3]];
+    let arr: [[Field; 2]; 1] = [[3, 3]];
     assert_eq(arr[0], array_input[1]);
 }
diff --git a/tooling/nargo_cli/tests/execution_success/slices/src/main.nr b/tooling/nargo_cli/tests/execution_success/slices/src/main.nr
index 8d53e013f96..25c2ac27157 100644
--- a/tooling/nargo_cli/tests/execution_success/slices/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/slices/src/main.nr
@@ -61,7 +61,6 @@ fn regression_2083() {
 
     let y = y.push_front((10, 11)); // [(10, 11), (1, 2), (3, 4), (5, 6)]
     let y = y.push_front((12, 13)); // [(12, 13), (10, 11), (1, 2), (3, 4), (5, 6)]
-
     assert(y[1].0 == 10);
 
     let y = y.insert(1, (55, 56)); // [(12, 13), (55, 56), (10, 11), (1, 2), (3, 4), (5, 6)]
@@ -149,15 +148,7 @@ fn merge_slices_else(x: Field) {
 // Test returning a merged slice without a mutation
 fn merge_slices_return(x: Field, y: Field) -> [Field] {
     let slice = [0; 2];
-    if x != y {
-        if x != 20 {
-            slice.push_back(y)
-        } else {
-            slice
-        }
-    } else {
-        slice
-    }
+    if x != y { if x != 20 { slice.push_back(y) } else { slice } } else { slice }
 }
 
 // Test mutating a slice inside of an if statement
diff --git a/tooling/nargo_cli/tests/execution_success/strings/src/main.nr b/tooling/nargo_cli/tests/execution_success/strings/src/main.nr
index 02e2fa678cd..42e8f7967ae 100644
--- a/tooling/nargo_cli/tests/execution_success/strings/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/strings/src/main.nr
@@ -25,7 +25,7 @@ fn main(message : pub str<11>, y : Field, hex_as_string : str<4>, hex_as_field :
 
     let hash = std::hash::pedersen([x]);
     std::println(hash);
-    
+
     assert(hex_as_string == "0x41");
     // assert(hex_as_string != 0x41); This will fail with a type mismatch between str[4] and Field
     assert(hex_as_field == 0x41);
diff --git a/tooling/nargo_cli/tests/execution_success/struct/src/main.nr b/tooling/nargo_cli/tests/execution_success/struct/src/main.nr
index 2bd5a1aec28..745815227d9 100644
--- a/tooling/nargo_cli/tests/execution_success/struct/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/struct/src/main.nr
@@ -34,11 +34,7 @@ struct MyStruct {
     my_nest: Nested,
 }
 fn test_struct_in_tuple(a_bool : bool,x:Field, y:Field) -> (MyStruct, bool) {
-    let my_struct = MyStruct {
-        my_bool: a_bool,
-        my_int: 5,
-        my_nest: Nested{a:x,b:y},
-    };
+    let my_struct = MyStruct { my_bool: a_bool, my_int: 5, my_nest: Nested { a: x, b: y } };
     (my_struct, a_bool)
 }
 
@@ -57,7 +53,7 @@ struct Unit;
 fn main(x: Field, y: Field) {
     let unit = Unit {};
 
-    let first = Foo::default(x,y);
+    let first = Foo::default(x, y);
     let p = Pair { first, second: 1 };
 
     assert(p.bar() == x);
@@ -65,7 +61,7 @@ fn main(x: Field, y: Field) {
     assert(p.first.array[0] != p.first.array[1]);
 
     // Nested structs
-    let (struct_from_tuple, a_bool) = test_struct_in_tuple(true,x,y);
+    let (struct_from_tuple, a_bool) = test_struct_in_tuple(true, x, y);
     assert(struct_from_tuple.my_bool == true);
     assert(a_bool == true);
     assert(struct_from_tuple.my_int == 5);
diff --git a/tooling/nargo_cli/tests/execution_success/to_be_bytes/src/main.nr b/tooling/nargo_cli/tests/execution_success/to_be_bytes/src/main.nr
index 81b08ed1785..025738c42e6 100644
--- a/tooling/nargo_cli/tests/execution_success/to_be_bytes/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/to_be_bytes/src/main.nr
@@ -5,8 +5,8 @@ fn main(x : Field) -> pub [u8; 31] {
     for i in 0..31 {
         bytes[i] = byte_array[i];
     }
-    if ( bytes[30] != 60) | (bytes[29] != 33) | (bytes[28] != 31) {
-        assert(false);    
+    if (bytes[30] != 60) | (bytes[29] != 33) | (bytes[28] != 31) {
+        assert(false);
     }
     bytes
 }
diff --git a/tooling/nargo_cli/tests/execution_success/to_bytes_integration/src/main.nr b/tooling/nargo_cli/tests/execution_success/to_bytes_integration/src/main.nr
index 43a35f05488..6825d7f5562 100644
--- a/tooling/nargo_cli/tests/execution_success/to_bytes_integration/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/to_bytes_integration/src/main.nr
@@ -4,7 +4,7 @@ fn main(x : Field, a: Field) {
     let y: Field = 2040124;
     let be_byte_array = y.to_be_bytes(31);
     let le_byte_array = x.to_le_bytes(31);
-    
+
     assert(le_byte_array[0] == 60);
     assert(le_byte_array[0] == be_byte_array[30]);
     assert(le_byte_array[1] == be_byte_array[29]);
diff --git a/tooling/nargo_cli/tests/execution_success/tuple_inputs/src/main.nr b/tooling/nargo_cli/tests/execution_success/tuple_inputs/src/main.nr
index 2fc44a8fc75..64621411c84 100644
--- a/tooling/nargo_cli/tests/execution_success/tuple_inputs/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/tuple_inputs/src/main.nr
@@ -27,6 +27,7 @@ fn main(pair : (Field, Field), x: [(u8, u8, u8); 2], struct_pair: (Foo, Bar)) ->
     } else {
         (pair.0 + 1, pair.0)
     };
+
     assert(u == pair.0 + 1);
     assert(v == pair.0);
 
diff --git a/tooling/nargo_cli/tests/execution_success/tuples/src/main.nr b/tooling/nargo_cli/tests/execution_success/tuples/src/main.nr
index e836c66a0fa..b6f6d695f2c 100644
--- a/tooling/nargo_cli/tests/execution_success/tuples/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/tuples/src/main.nr
@@ -7,12 +7,8 @@ fn main(x: Field, y: Field) {
     assert(a == 0);
     assert(b == 1);
 
-    let (u, v) = if x as u32 < 1 {
-        (x, x + 1)
-    } else {
-        (x + 1, x)
-    };
-    assert(u == x+1);
+    let (u, v) = if x as u32 < 1 { (x, x + 1) } else { (x + 1, x) };
+    assert(u == x + 1);
     assert(v == x);
 
     // Test mutating tuples
diff --git a/tooling/nargo_cli/tests/execution_success/type_aliases/src/main.nr b/tooling/nargo_cli/tests/execution_success/type_aliases/src/main.nr
index 573a501367f..c9db6d81f90 100644
--- a/tooling/nargo_cli/tests/execution_success/type_aliases/src/main.nr
+++ b/tooling/nargo_cli/tests/execution_success/type_aliases/src/main.nr
@@ -22,9 +22,7 @@ fn main(x : [Field; 2]) {
     let e: Three = (c, d);
     assert(e.0 == 1);
 
-    let s = MyStruct { 
-        foo: 10
-    };
+    let s = MyStruct { foo: 10 };
     assert(s.foo == 10);
 
     let _regression2502: Regression2502Alias = Regression2502 {};
diff --git a/tooling/nargo_cli/tests/noir_test_failure/should_fail_mismatch/src/main.nr b/tooling/nargo_cli/tests/noir_test_failure/should_fail_mismatch/src/main.nr
index b2672221c34..923c27d17d1 100644
--- a/tooling/nargo_cli/tests/noir_test_failure/should_fail_mismatch/src/main.nr
+++ b/tooling/nargo_cli/tests/noir_test_failure/should_fail_mismatch/src/main.nr
@@ -1,4 +1,3 @@
-
 #[test(should_fail_with = "Not equal")]
 fn test_different_string() {
     assert_eq(0, 1, "Different string");
@@ -14,4 +13,4 @@ fn test_with_extra_space() {
 #[test(should_fail_with = "Not equal")]
 fn test_runtime_mismatch() {
     assert_eq(dep::std::hash::pedersen([27])[0], 0, "Not equal ");
-}
\ No newline at end of file
+}
diff --git a/tooling/nargo_cli/tests/test_libraries/diamond_deps_2/src/lib.nr b/tooling/nargo_cli/tests/test_libraries/diamond_deps_2/src/lib.nr
index 7ee59d2bc9d..b0d09c70648 100644
--- a/tooling/nargo_cli/tests/test_libraries/diamond_deps_2/src/lib.nr
+++ b/tooling/nargo_cli/tests/test_libraries/diamond_deps_2/src/lib.nr
@@ -1,6 +1,5 @@
 global RESOLVE_THIS = 3;
 
-
 pub fn call_dep2(x : Field, y : Field) -> Field {
     x + y
 }
diff --git a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
index 8deda68c051..67b8c84bdcd 100644
--- a/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
+++ b/tooling/noir_js/test/noir_compiled_examples/assert_lt/src/main.nr
@@ -1,4 +1,4 @@
 fn main(x : u64, y : pub u64) -> pub u64 {
-  assert(x < y);
-  x + y
+    assert(x < y);
+    x + y
 }