lint

Author: jialinli98

src/_string_tools/slice_packed_field.nr

@@ -594,11 +594,37 @@ fn divmod_31(numerator: u16) -> (u16, u16) {
     (quotient, remainder)
 }
 
+/**
+ * @brief converts a 16 bit value into 16 fake bools (Field elements that are 0 or 1)
+ **/
+unconstrained fn decompose(val: Field) -> [Field; 16] {
+    let mut r: [Field; 16] = [0; 16];
+
+    let mut it = val as u32;
+    for i in 0..16 {
+        r[i] = (it & 1) as Field;
+        it >>= 1;
+    }
+    r
+}
+
 // 5 gates?
-pub fn get_last_limb_path<let OutputFields: u32>(last_limb_index: Field) -> [u1; OutputFields] {
+pub fn get_last_limb_path<let OutputFields: u32>(last_limb_index: Field) -> [Field; OutputFields] {
     // TODO we offset by 1 explain why (0 byte length produces 0 - 1 which = invalid array index. we just add 1 and increase array length by 1 to compensate)
     let path = LAST_LIMB_PATH[cast_num_to_u32(last_limb_index + 1)]; // 2
-    path.to_le_bits::<OutputFields>()
+    // Safety: check the comments below
+    let path_valid_bits = unsafe { decompose(path) };
+    let mut path_valid_sum: Field = 0;
+    let mut path_valid_output: [Field; OutputFields] = [0; OutputFields];
+    for i in 0..OutputFields {
+        // we check that the path valid bits are binary
+        assert(path_valid_bits[i] * path_valid_bits[i] - path_valid_bits[i] == 0);
+        path_valid_sum += (path_valid_bits[i] * (1 << i as u8) as Field);
+        path_valid_output[i] = path_valid_bits[i];
+    }
+    // we check that the path valid bits sum to the path
+    assert(path_valid_sum == path);
+    path_valid_output
 }
 
 /**
@@ -702,13 +728,13 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
     // 1, 70.5
     let index_of_output_limb: Field = (num_bytes_div_31 as Field - num_bytes_mod_31_is_0 as Field);
     // 5, 75.5
-    let path_valid_output: [u1; OutputFields] = get_last_limb_path(index_of_output_limb);
+    let path_valid_output: [Field; OutputFields] = get_last_limb_path(index_of_output_limb);
 
     // 2, 77.5
     let tail_shift = BYTE_SHIFT[cast_num_to_u32(num_unused_bytes_in_start_limb)];
 
     // 51, 128.5
-    let mut result: [Field; OutputFields] = [0; OutputFields];
+    let mut result = [0; OutputFields];
     let mut previous = tail;
     for i in 0..(OutputFields - 1) {
         // 0
@@ -722,9 +748,9 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
         // 1, 48
         let combined = previous * tail_shift + head;
         // 1, 49
-        result[i] = if slice_valid == 1 { combined } else { 0 };
+        result[i] = combined * slice_valid;
         // 2, 51
-        previous = if slice_valid == 1 { tail } else { previous };
+        previous = (tail - previous) * slice_valid + previous;
     }
 
     // 2, 130.5
@@ -761,10 +787,9 @@ pub fn slice_fields<let InputFields: u32, let OutputFields: u32>(
     std::as_witness(last_limb);
 
     let mut path: [Field; OutputFields] = [0; OutputFields];
-    path[0] = (1 - path_valid_output[0] as Field);
+    path[0] = (1 - path_valid_output[0]);
     for i in 1..OutputFields {
-        path[i] = path_valid_output[i - 1] as Field
-            - path_valid_output[i] as Field * path_valid_output[i - 1] as Field;
+        path[i] = path_valid_output[i] * -path_valid_output[i - 1] + path_valid_output[i - 1];
     }
 
     for i in 0..OutputFields {
@@ -857,7 +882,7 @@ mod test {
             for j in 0..18 {
                 let start_byte: u32 = text.len() - num_bytes - byte_positions[j];
                 let mut expected_slices: [Field; 3] =
-                    // Safety: this is a test
+                // Safety: this is a test
                     unsafe { build_slices_for_test(text, start_byte, num_bytes) };
                 let result_slices: [Field; 3] =
                     slice_fields(slices, start_byte as Field, num_bytes as Field);

src/json.nr

@@ -267,14 +267,13 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
             tokens[i] = token;
             // 13 gates
             let TokenFlags {
-                create_json_entry,
-                is_end_of_object_or_array,
-                is_start_of_object_or_array,
-                new_context,
-                is_key_token: update_key,
-                is_value_token,
-                preserve_num_entries,
-            } = TokenFlags::from_field(
+    create_json_entry,
+    is_end_of_object_or_array,
+    is_start_of_object_or_array,
+    new_context,
+    is_key_token: update_key,
+    is_value_token,
+    preserve_num_entries,} = TokenFlags::from_field(
                 TOKEN_FLAGS_TABLE[cast_num_to_u32(token) + context * NUM_TOKENS],
             );
 
@@ -456,12 +455,8 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
             // 2 gates
             let capture_flags = JSON_CAPTURE_TABLE[cast_num_to_u32(encoded_ascii)];
             // 5 gates
-            let ScanData {
-                scan_token,
-                push_transcript,
-                increase_length,
-                is_potential_escape_sequence,
-            } = ScanData::from_field(capture_flags);
+            let ScanData { scan_token, push_transcript, increase_length, is_potential_escape_sequence } =
+                ScanData::from_field(capture_flags);
 
             // 2 gates
             let raw = raw_transcript[cast_num_to_u32(transcript_ptr)];
@@ -674,8 +669,8 @@ unconstrained fn __build_transcript<let NumBytes: u32, let MaxNumTokens: u32>(
         let encoded_ascii = previous_was_potential_escape_sequence as Field * 1024
             + scan_mode * 256
             + ascii as Field;
-        let ScanData { scan_token, push_transcript, increase_length, is_potential_escape_sequence }
-             = ScanData::from_field(JSON_CAPTURE_TABLE[cast_num_to_u32(encoded_ascii)]);
+        let ScanData { scan_token, push_transcript, increase_length, is_potential_escape_sequence } =
+            ScanData::from_field(JSON_CAPTURE_TABLE[cast_num_to_u32(encoded_ascii)]);
 
         if push_transcript {
             let new_entry = RawTranscriptEntry::to_field(