chore: run formatter

noir_stdlib/src/field_element.nr

@@ -101,8 +101,8 @@ pub fn modulus_le_bytes() -> [u8] {}
 pub fn bytes32_to_field(bytes32: [u8; 32]) -> field {
     // Convert it to a field element
     let mut v = 1;
-    let mut high = 0 as plain::field;
-    let mut low = 0 as plain::field;
+    let mut high = 0 as field;
+    let mut low = 0 as field;
 
     for i in 0..16 {
         high = high + (bytes32[15 - i] as field) * v;

noir_stdlib/src/uint128.nr

@@ -12,7 +12,7 @@ impl U128 {
 
     pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {
         // in order to handle multiplication, we need to represent the product of two u64 without overflow
-        assert(crate::field::modulus_num_bits() as u32 > 128);
+        assert(crate::field_element::modulus_num_bits() as u32 > 128);
         U128 { lo: lo as Field, hi: hi as Field }
     }
 
@@ -129,7 +129,7 @@ impl U128 {
         let low = self.lo * b.lo;
         let lo = low as u64 as Field;
         let carry = (low - lo) / pow64;
-        let high = if crate::field::modulus_num_bits() as u32 > 196 {
+        let high = if crate::field_element::modulus_num_bits() as u32 > 196 {
             (self.lo + self.hi) * (b.lo + b.hi) - low + carry
         } else {
             self.lo * b.hi + self.hi * b.lo + carry
@@ -175,7 +175,7 @@ impl Mul for U128 {
         let low = self.lo*b.lo;
         let lo = low as u64 as Field;
         let carry = (low - lo) / pow64;
-        let high = if crate::field::modulus_num_bits() as u32 > 196 {
+        let high = if crate::field_element::modulus_num_bits() as u32 > 196 {
             (self.lo+self.hi)*(b.lo+b.hi) - low + carry
         } else {
             self.lo*b.hi + self.hi*b.lo + carry

test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr

@@ -8,18 +8,18 @@ fn main() {
     assert((x / y) == div(x, y));
 }
 
-unconstrained fn add(x: Field, y: Field) -> Field {
+unconstrained fn add(x: field, y: field) -> field {
     x + y
 }
 
-unconstrained fn sub(x: Field, y: Field) -> Field {
+unconstrained fn sub(x: field, y: field) -> field {
     x - y
 }
 
-unconstrained fn mul(x: Field, y: Field) -> Field {
+unconstrained fn mul(x: field, y: field) -> field {
     x * y
 }
 
-unconstrained fn div(x: Field, y: Field) -> Field {
+unconstrained fn div(x: field, y: field) -> field {
     x / y
 }

test_programs/compile_success_empty/closure_explicit_types/src/main.nr

@@ -1,13 +1,13 @@
-fn ret_normal_lambda1() -> fn() -> Field {
+fn ret_normal_lambda1() -> fn() -> field {
     || 10
 }
 // return lamda that captures a thing
-fn ret_closure1() -> fn[(Field,)]() -> Field {
+fn ret_closure1() -> fn[(field,)]() -> field {
     let x = 20;
     || x + 10
 }
 // return lamda that captures two things
-fn ret_closure2() -> fn[(Field, Field)]() -> Field {
+fn ret_closure2() -> fn[(field, field)]() -> field {
     let x = 20;
     let y = 10;
     || x + y + 10
@@ -19,19 +19,19 @@ fn ret_closure3() -> fn[(u32, u64)]() -> u64 {
     || x as u64 + y + 10
 }
 // accepts closure that has 1 thing in its env, calls it and returns the result
-fn accepts_closure1(f: fn[(Field,)]() -> Field) -> Field {
+fn accepts_closure1(f: fn[(field,)]() -> field) -> field {
     f()
 }
 // accepts closure that has 1 thing in its env and returns it
-fn accepts_closure2(f: fn[(Field,)]() -> Field) -> fn[(Field,)]() -> Field {
+fn accepts_closure2(f: fn[(field,)]() -> field) -> fn[(field,)]() -> field {
     f
 }
 // accepts closure with different types in the capture group
 fn accepts_closure3(f: fn[(u32, u64)]() -> u64) -> u64 {
     f()
 }
 // generic over closure environments
-fn add_results<Env1, Env2>(f1: fn[Env1]() -> Field, f2: fn[Env2]() -> Field) -> Field {
+fn add_results<Env1, Env2>(f1: fn[Env1]() -> field, f2: fn[Env2]() -> field) -> field {
     f1() + f2()
 }
 // a *really* generic function

test_programs/compile_success_empty/comptime_recursion_regression/src/main.nr

@@ -1,4 +1,4 @@
-fn main(x: Field, y: Field) {
+fn main(x: field, y: field) {
     let flag = (x == 1) | (y == 2);
     assert(flag | false == flag);
 }

test_programs/compile_success_empty/conditional_regression_547/src/main.nr

@@ -1,4 +1,4 @@
-fn main(x: Field) -> pub Field {
+fn main(x: field) -> pub field {
     // Regression test for issue #547
     // Warning: it must be kept at the start of main
     let arr: [u8; 2] = [1, 2];
@@ -11,6 +11,6 @@ fn main(x: Field) -> pub Field {
     x + safe_inverse(0)
 }
 
-fn safe_inverse(n: Field) -> Field {
+fn safe_inverse(n: field) -> field {
     if n == 0 { 0 } else { 1 / n }
 }

test_programs/compile_success_empty/generators/src/main.nr

@@ -2,7 +2,7 @@
 // the syntax for these return types is very difficult to get right :/
 // for arguments this can be handled with a generic Env (or with Fn traits when we add them)
 // but for return types neither fo these will help, you need to type out the exact type
-fn make_counter() -> fn[(&mut Field,)]() -> Field {
+fn make_counter() -> fn[(&mut field,)]() -> field {
     let mut x = &mut 0;
 
     || {
@@ -11,7 +11,7 @@ fn make_counter() -> fn[(&mut Field,)]() -> Field {
     }
 }
 
-fn fibonacci_generator() -> fn[(&mut Field, &mut Field)]() -> Field {
+fn fibonacci_generator() -> fn[(&mut field, &mut field)]() -> field {
     let mut x = &mut 1;
     let mut y = &mut 2;
 
@@ -26,7 +26,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] {
+fn get_some<Env>(generator: fn[Env]() -> field) -> [field; 5] {
     [0, 0, 0, 0, 0].map(|_| generator())
 }
 

test_programs/compile_success_empty/higher_order_fn_selector/src/main.nr

@@ -1,12 +1,12 @@
-fn g(x: &mut Field) -> () {
+fn g(x: &mut field) -> () {
     *x *= 2;
 }
 
-fn h(x: &mut Field) -> () {
+fn h(x: &mut field) -> () {
     *x *= 3;
 }
 
-fn selector(flag: &mut bool) -> fn(&mut Field) -> () {
+fn selector(flag: &mut bool) -> fn(&mut field) -> () {
     let my_func = if *flag { g } else { h };
     // Flip the flag for the next function call
     *flag = !(*flag);

test_programs/compile_success_empty/instruction_deduplication/src/main.nr

@@ -1,4 +1,4 @@
-fn main(x: Field) {
+fn main(x: field) {
     // This is a regression test for #2450.
     // The compiler should recognize that the `(x as u32)` instructions are duplicates and so have the same output.
     assert(x as u32 == x as u32);

test_programs/compile_success_empty/intrinsic_die/src/main.nr

@@ -1,6 +1,6 @@
 use dep::std;
 // This test checks that we perform dead-instruction-elimination on intrinsic functions.
-fn main(x: Field) {
+fn main(x: field) {
     let hash = std::hash::pedersen_commitment([x]);
     let _p1 = std::scalar_mul::fixed_base_embedded_curve(x, 0);
 }

test_programs/compile_success_empty/main_return/src/main.nr

@@ -1,3 +1,3 @@
-fn main(x: pub Field) -> pub Field {
+fn main(x: pub field) -> pub field {
     x
 }

test_programs/compile_success_empty/numeric_generics/src/main.nr

@@ -14,7 +14,7 @@ fn main() {
     assert(foo(itWorks2).data[0] == itWorks2.data[0] + 1);
 }
 
-fn id<I>(x: [Field; I]) -> [Field; I] {
+fn id<I>(x: [field; I]) -> [field; I] {
     x
 }
 
@@ -23,7 +23,7 @@ struct MyStruct<S> {
 }
 
 impl<S> MyStruct<S> {
-    fn insert(mut self: Self, index: Field, elem: Field) -> Self {
+    fn insert(mut self: Self, index: field, elem: field) -> Self {
         // Regression test for numeric generics on impls
         assert(index as u64 < S as u64);
 

test_programs/compile_success_empty/references_aliasing/src/main.nr

@@ -7,7 +7,7 @@ fn main() {
     regression_2445();
 }
 
-fn increment(mut r: &mut Field) {
+fn increment(mut r: &mut field) {
     *r = *r + 1;
 }
 // If aliasing within arrays and constant folding within the mem2reg pass aren't

test_programs/compile_success_empty/ret_fn_ret_cl/src/main.nr

@@ -1,8 +1,8 @@
-fn f(x: Field) -> Field {
+fn f(x: field) -> field {
     x + 1
 }
 
-fn ret_fn() -> fn(Field) -> Field {
+fn ret_fn() -> fn(field) -> field {
     f
 }
 // TODO: in the advanced implicitly generic function with closures branch
@@ -16,14 +16,14 @@ fn ret_fn() -> fn(Field) -> Field {
 //     };
 //     inner_closure
 // }
-fn ret_lambda() -> fn(Field) -> Field {
+fn ret_lambda() -> fn(field) -> field {
     let cl = |z: Field| -> Field {
         z + 1
     };
     cl
 }
 
-fn main(x: Field) {
+fn main(x: field) {
     let result_fn = ret_fn();
     assert(result_fn(x) == x + 1);
     // let result_closure = ret_closure();

test_programs/compile_success_empty/simple_array_param/src/main.nr

@@ -1,6 +1,6 @@
 // This program tests:
 // - the allocation of virtual arrays for array params to main
 // - load instructions for such arrays
-fn main(xs: [Field; 2]) -> pub Field {
+fn main(xs: [field; 2]) -> pub field {
     xs[1]
 }

test_programs/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) {}
+fn main(_x: field, _y: pub field) {}

test_programs/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;
 }

test_programs/compile_success_empty/specialization/src/main.nr

@@ -1,13 +1,13 @@
 struct Foo<T> {}
 
 impl Foo<u32> {
-    fn foo(_self: Self) -> Field {
+    fn foo(_self: Self) -> field {
         1
     }
 }
 
 impl Foo<u64> {
-    fn foo(_self: Self) -> Field {
+    fn foo(_self: Self) -> field {
         2
     }
 }

test_programs/compile_success_empty/trait_associated_member_names_clashes/src/main.nr

@@ -10,7 +10,7 @@ struct Struct1 {
 }
 
 impl Struct1 {
-    fn tralala() -> Field {
+    fn tralala() -> field {
         123456
     }
 }

test_programs/compile_success_empty/trait_default_implementation/src/main.nr

@@ -19,7 +19,7 @@ impl MyDefault for Foo {
     }
 }
 
-fn main(x: Field) {
+fn main(x: field) {
     let first = Foo::method2(x);
     assert(first == x);
 }

test_programs/compile_success_empty/trait_generics/src/main.nr

@@ -44,13 +44,13 @@ impl Serializable<2> for Data {
     }
 }
 
-fn sum<T, M>(data: T) -> Field where T: Serializable<M> {
+fn sum<T, M>(data: T) -> field where T: Serializable<M> {
     let serialized = data.serialize();
     serialized.fold(0, |acc, elem| acc + elem)
 }
 
 // Test static trait method syntax
-fn sum_static<T, M>(data: T) -> Field where T: Serializable<M> {
+fn sum_static<T, M>(data: T) -> field where T: Serializable<M> {
     let serialized = Serializable::serialize(data);
     serialized.fold(0, |acc, elem| acc + elem)
 }

test_programs/compile_success_empty/trait_override_implementation/src/main.nr

@@ -43,7 +43,7 @@ impl F for Bar {
 //     fn f1(self) -> Field { 101 }
 //     fn f5(self) -> Field { 505 }
 // }
-fn main(x: Field) {
+fn main(x: field) {
     let first = Foo::method2(x);
     assert(first == 3 * x);
 

test_programs/compile_success_empty/trait_where_clause/src/main.nr

@@ -36,7 +36,7 @@ fn assert_asd_eq_100<T>(t: T) where T: crate::the_trait::Asd {
     assert(t.asd() == 100);
 }
 
-fn add_one_to_static_function<T>(t: T) -> Field where T: StaticTrait {
+fn add_one_to_static_function<T>(t: T) -> field where T: StaticTrait {
     T::static_function(t) + 1
 }
 

test_programs/compile_success_empty/traits/src/main.nr

@@ -15,7 +15,7 @@ impl MyDefault for Foo {
     }
 }
 
-fn main(x: Field, y: Field) {
+fn main(x: field, y: field) {
     let first = Foo::my_default(x, y);
     assert(first.bar == x);
 }

test_programs/compile_success_empty/unused_variables/src/main.nr

@@ -1 +1 @@
-fn main(x: Field, y: pub Field) {}
+fn main(x: field, y: pub field) {}

test_programs/compile_success_empty/vectors/src/main.nr

@@ -1,6 +1,6 @@
 use dep::std::collections::vec::Vec;
 
-fn main(x: Field, y: pub Field) {
+fn main(x: field, y: pub field) {
     let mut vector = Vec::new();
 
     assert(vector.len() == 0);

test_programs/execution_success/1327_concrete_in_generic/src/main.nr

@@ -30,7 +30,7 @@ impl<T_D> C<T_D> {
         C { t_d_interface }
     }
 
-    fn call_method_of_t_d(self, t_d: T_D) -> Field {
+    fn call_method_of_t_d(self, t_d: T_D) -> field {
         let some_method_on_t_d = self.t_d_interface.some_method_on_t_d;
         some_method_on_t_d(t_d)
     }
@@ -45,15 +45,15 @@ struct D {
         d: Field,
     }
 
-fn d_method(input: D) -> Field {
+fn d_method(input: D) -> field {
     input.d * input.d
 }
 
 fn get_d_method_interface() -> MethodInterface<D> {
     MethodInterface { some_method_on_t_d: d_method }
 }
 // ---
-fn main(input: Field) -> pub Field {
+fn main(input: field) -> pub field {
     let b: B<C<D>> = B::new(new_concrete_c_over_d);
     let c: C<D> = b.get_t_c(); // Singleton<Note>
     let d: D = D { d: input }; // Note