chore: remove useless casts (#68)

Author: TomAFrench

src/_string_tools/slice_packed_field.nr

@@ -756,7 +756,7 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
     let use_previous_for_last_limb: Field = extra_head_section + bytes_fit_into_limb;
 
     // 1, 132.5
-    let mut index_of_overflow_limb = start_index + num_whole_limbs + 1;
+    let index_of_overflow_limb = start_index + num_whole_limbs + 1;
     // 2, 134.5
     let last_limb_from_data = data[index_of_overflow_limb as u32];
     // 2, 136.5

src/_table_generation/make_tables.nr

@@ -288,8 +288,8 @@ unconstrained fn make_token_validation_table() -> [Field; NUM_TOKENS * NUM_TOKEN
     let mut flattened_flags: [Field; NUM_TOKENS * NUM_TOKENS * 3] =
         [0; NUM_TOKENS * NUM_TOKENS * 3];
     let NN = (NUM_TOKENS * NUM_TOKENS);
-    for j in 0..NUM_TOKENS as u32 {
-        for k in 0..NUM_TOKENS as u32 {
+    for j in 0..NUM_TOKENS {
+        for k in 0..NUM_TOKENS {
             flattened_flags[OBJECT_LAYER * NN + j * NUM_TOKENS + k] = object_layer_flags[j][k];
             flattened_flags[ARRAY_LAYER * NN + j * NUM_TOKENS + k] = array_layer_flags[j][k];
             flattened_flags[SINGLE_VALUE_LAYER * NN + j * NUM_TOKENS + k] =
@@ -467,20 +467,20 @@ unconstrained fn generate_token_flags_table() -> [Field; NUM_TOKENS * 2] {
     numeric_flags.new_context = ARRAY_LAYER as Field;
     literal_flags.new_context = ARRAY_LAYER as Field;
 
-    flags[NUM_TOKENS + (NO_TOKEN as u32)] = no_token_flags;
-    flags[NUM_TOKENS + (BEGIN_OBJECT_TOKEN as u32)] = begin_object_flags;
-    flags[NUM_TOKENS + (END_OBJECT_TOKEN as u32)] = end_object_flags;
-    flags[NUM_TOKENS + (BEGIN_ARRAY_TOKEN as u32)] = begin_array_flags;
-    flags[NUM_TOKENS + (END_ARRAY_TOKEN as u32)] = end_array_flags;
-    flags[NUM_TOKENS + (KEY_SEPARATOR_TOKEN as u32)] = no_token_flags;
-    flags[NUM_TOKENS + (VALUE_SEPARATOR_TOKEN as u32)] = no_token_flags;
-    flags[NUM_TOKENS + (STRING_TOKEN as u32)] = string_flags;
-    flags[NUM_TOKENS + (NUMERIC_TOKEN as u32)] = numeric_flags;
-    flags[NUM_TOKENS + (LITERAL_TOKEN as u32)] = literal_flags;
-    flags[NUM_TOKENS + (KEY_TOKEN as u32)] = key_token_flags;
+    flags[NUM_TOKENS + NO_TOKEN] = no_token_flags;
+    flags[NUM_TOKENS + BEGIN_OBJECT_TOKEN] = begin_object_flags;
+    flags[NUM_TOKENS + END_OBJECT_TOKEN] = end_object_flags;
+    flags[NUM_TOKENS + BEGIN_ARRAY_TOKEN] = begin_array_flags;
+    flags[NUM_TOKENS + END_ARRAY_TOKEN] = end_array_flags;
+    flags[NUM_TOKENS + KEY_SEPARATOR_TOKEN] = no_token_flags;
+    flags[NUM_TOKENS + VALUE_SEPARATOR_TOKEN] = no_token_flags;
+    flags[NUM_TOKENS + STRING_TOKEN] = string_flags;
+    flags[NUM_TOKENS + NUMERIC_TOKEN] = numeric_flags;
+    flags[NUM_TOKENS + LITERAL_TOKEN] = literal_flags;
+    flags[NUM_TOKENS + KEY_TOKEN] = key_token_flags;
 
     let mut result: [Field; NUM_TOKENS * 2] = [0; NUM_TOKENS * 2];
-    for i in 0..(NUM_TOKENS as u32 * 2) {
+    for i in 0..(NUM_TOKENS * 2) {
         result[i] = flags[i].to_field();
     }
     result

src/getters.nr

@@ -94,7 +94,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         assert(self.layer_type_of_root != ARRAY_LAYER, "cannot extract array elements via a key");
 
         let hasher: ByteHasher<MaxKeyFields> = ByteHasher {};
-        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len() as u32);
+        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len());
         let two_pow_216 = 0x100000000000000000000000000000000000000000000000000000000;
 
         let keyhash = keyhash + self.root_id * two_pow_216;
@@ -147,7 +147,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         assert(self.layer_type_of_root != ARRAY_LAYER, "cannot extract array elements via a key");
 
         let hasher: ByteHasher<MaxKeyFields> = ByteHasher {};
-        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len() as u32);
+        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len());
         let two_pow_216 = 0x100000000000000000000000000000000000000000000000000000000;
 
         let keyhash = keyhash + self.root_id * two_pow_216;
@@ -395,7 +395,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
             case 3: entry A > keyhash > entryB
         */
         let hasher: ByteHasher<MaxKeyFields> = ByteHasher {};
-        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len() as u32);
+        let keyhash = hasher.get_keyhash_var(key.storage(), 0, key.len());
 
         let HASH_MAXIMUM = 0x1000000000000000000000000000000000000000000000000000000000000 - 1;
         let two_pow_216 = 0x100000000000000000000000000000000000000000000000000000000;

src/keyhash.nr

@@ -18,7 +18,7 @@ impl<let KeyFields: u32> FieldHasher<KeyFields> {
         key_length: Field,
     ) -> Field {
         let key_fields: [Field; KeyFields] = slice_fields(packed_fields, body_index, key_length);
-        let hashed = poseidon::poseidon2::Poseidon2::hash(key_fields, KeyFields as u32);
+        let hashed = poseidon::poseidon2::Poseidon2::hash(key_fields, KeyFields);
         slice_200_bits_from_field(hashed)
     }
 }
@@ -60,7 +60,7 @@ impl<let KeyFields: u32> ByteHasher<KeyFields> {
             key_fields[j] = limb;
         }
 
-        let hashed_full = poseidon::poseidon2::Poseidon2::hash(key_fields, KeyFields as u32);
+        let hashed_full = poseidon::poseidon2::Poseidon2::hash(key_fields, KeyFields);
 
         let mut r = slice_200_bits_from_field(hashed_full);
         r