fix clippy lints for Rust 1.86 (#193)

davidhewitt · web-flow · commit 890d622373a3 · 2025-04-10T19:54:44.000Z
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -21,7 +21,7 @@ repos:
     pass_filenames: false
   - id: clippy
     name: Clippy
-    entry: cargo clippy -F python -- -D warnings
+    entry: cargo clippy -F python --workspace --all-targets -- -D warnings
     types: [rust]
     language: system
     pass_filenames: false
diff --git a/crates/jiter-python/Cargo.toml b/crates/jiter-python/Cargo.toml
@@ -8,6 +8,7 @@ keywords = {workspace = true}
 categories = {workspace = true}
 homepage = {workspace = true}
 repository = {workspace = true}
+rust-version = { workspace = true }
 
 [dependencies]
 pyo3 = { workspace = true, features = ["num-bigint"] }
diff --git a/crates/jiter/Cargo.toml b/crates/jiter/Cargo.toml
@@ -10,6 +10,7 @@ keywords = { workspace = true }
 categories = { workspace = true }
 homepage = { workspace = true }
 repository = { workspace = true }
+rust-version = { workspace = true }
 
 [dependencies]
 num-bigint = { version = "0.4.4", optional = true }
diff --git a/crates/jiter/benches/main.rs b/crates/jiter/benches/main.rs
@@ -20,7 +20,7 @@ fn jiter_value(path: &str, bench: &mut Bencher) {
     bench.iter(|| {
         let v = JsonValue::parse(black_box(json_data), false).unwrap();
         black_box(v)
-    })
+    });
 }
 
 fn jiter_skip(path: &str, bench: &mut Bencher) {
@@ -29,7 +29,7 @@ fn jiter_skip(path: &str, bench: &mut Bencher) {
     bench.iter(|| {
         let mut jiter = Jiter::new(json_data);
         jiter.next_skip().unwrap();
-    })
+    });
 }
 
 fn jiter_iter_big(path: &str, bench: &mut Bencher) {
@@ -52,7 +52,7 @@ fn jiter_iter_big(path: &str, bench: &mut Bencher) {
                 break;
             }
         }
-    })
+    });
 }
 
 fn find_string(jiter: &mut Jiter) -> String {
@@ -77,7 +77,7 @@ fn jiter_iter_pass2(path: &str, bench: &mut Bencher) {
         let string = find_string(&mut jiter);
         jiter.finish().unwrap();
         black_box(string)
-    })
+    });
 }
 
 fn jiter_iter_string_array(path: &str, bench: &mut Bencher) {
@@ -94,7 +94,7 @@ fn jiter_iter_string_array(path: &str, bench: &mut Bencher) {
             black_box(i.len());
         }
         jiter.finish().unwrap();
-    })
+    });
 }
 
 fn jiter_iter_true_array(path: &str, bench: &mut Bencher) {
@@ -109,7 +109,7 @@ fn jiter_iter_true_array(path: &str, bench: &mut Bencher) {
             let i = jiter.known_bool(peek).unwrap();
             black_box(i);
         }
-    })
+    });
 }
 
 fn jiter_iter_true_object(path: &str, bench: &mut Bencher) {
@@ -127,7 +127,7 @@ fn jiter_iter_true_object(path: &str, bench: &mut Bencher) {
                 black_box((key, value));
             }
         }
-    })
+    });
 }
 
 fn jiter_iter_ints_array(path: &str, bench: &mut Bencher) {
@@ -142,7 +142,7 @@ fn jiter_iter_ints_array(path: &str, bench: &mut Bencher) {
             let i = jiter.known_int(peek).unwrap();
             black_box(i);
         }
-    })
+    });
 }
 
 fn jiter_iter_floats_array(path: &str, bench: &mut Bencher) {
@@ -157,7 +157,7 @@ fn jiter_iter_floats_array(path: &str, bench: &mut Bencher) {
             let i = jiter.known_float(peek).unwrap();
             black_box(i);
         }
-    })
+    });
 }
 
 fn jiter_string(path: &str, bench: &mut Bencher) {
@@ -168,7 +168,7 @@ fn jiter_string(path: &str, bench: &mut Bencher) {
         let string = jiter.next_str().unwrap();
         black_box(string);
         jiter.finish().unwrap();
-    })
+    });
 }
 
 fn serde_value(path: &str, bench: &mut Bencher) {
@@ -177,7 +177,7 @@ fn serde_value(path: &str, bench: &mut Bencher) {
     bench.iter(|| {
         let value: Value = serde_json::from_slice(json_data).unwrap();
         black_box(value);
-    })
+    });
 }
 
 fn serde_str(path: &str, bench: &mut Bencher) {
@@ -186,7 +186,7 @@ fn serde_str(path: &str, bench: &mut Bencher) {
     bench.iter(|| {
         let value: String = serde_json::from_slice(json_data).unwrap();
         black_box(value);
-    })
+    });
 }
 
 macro_rules! test_cases {
@@ -260,7 +260,7 @@ fn string_array_jiter_value_owned(bench: &mut Bencher) {
     bench.iter(|| {
         let v = JsonValue::parse_owned(black_box(json_data), false, PartialMode::Off).unwrap();
         black_box(v)
-    })
+    });
 }
 
 fn medium_response_jiter_value_owned(bench: &mut Bencher) {
@@ -269,7 +269,7 @@ fn medium_response_jiter_value_owned(bench: &mut Bencher) {
     bench.iter(|| {
         let v = JsonValue::parse_owned(black_box(json_data), false, PartialMode::Off).unwrap();
         black_box(v)
-    })
+    });
 }
 
 fn x100_serde_iter(bench: &mut Bencher) {
diff --git a/crates/jiter/benches/python.rs b/crates/jiter/benches/python.rs
@@ -18,7 +18,7 @@ fn python_parse_numeric(bench: &mut Bencher) {
                 )
                 .unwrap()
         });
-    })
+    });
 }
 
 fn python_parse_other(bench: &mut Bencher) {
@@ -29,10 +29,10 @@ fn python_parse_other(bench: &mut Bencher) {
                 .python_parse(py, br#"["string", true, false, null]"#)
                 .unwrap()
         });
-    })
+    });
 }
 
-fn _python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMode) {
+fn python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMode) {
     let mut file = File::open(path).unwrap();
     let mut contents = String::new();
     file.read_to_string(&mut contents).unwrap();
@@ -48,56 +48,56 @@ fn _python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMo
             .python_parse(py, json_data)
             .unwrap()
         });
-    })
+    });
 }
 
 fn python_parse_massive_ints_array(bench: &mut Bencher) {
-    _python_parse_file("./benches/massive_ints_array.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/massive_ints_array.json", bench, StringCacheMode::All);
 }
 
 fn python_parse_medium_response_not_cached(bench: &mut Bencher) {
-    _python_parse_file("./benches/medium_response.json", bench, StringCacheMode::None);
+    python_parse_file("./benches/medium_response.json", bench, StringCacheMode::None);
 }
 
 fn python_parse_medium_response(bench: &mut Bencher) {
-    _python_parse_file("./benches/medium_response.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/medium_response.json", bench, StringCacheMode::All);
 }
 
 fn python_parse_true_object_not_cached(bench: &mut Bencher) {
-    _python_parse_file("./benches/true_object.json", bench, StringCacheMode::None);
+    python_parse_file("./benches/true_object.json", bench, StringCacheMode::None);
 }
 
 fn python_parse_string_array_not_cached(bench: &mut Bencher) {
-    _python_parse_file("./benches/string_array.json", bench, StringCacheMode::None);
+    python_parse_file("./benches/string_array.json", bench, StringCacheMode::None);
 }
 
 fn python_parse_string_array(bench: &mut Bencher) {
-    _python_parse_file("./benches/string_array.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/string_array.json", bench, StringCacheMode::All);
 }
 
 fn python_parse_x100_not_cached(bench: &mut Bencher) {
-    _python_parse_file("./benches/x100.json", bench, StringCacheMode::None);
+    python_parse_file("./benches/x100.json", bench, StringCacheMode::None);
 }
 
 fn python_parse_x100(bench: &mut Bencher) {
-    _python_parse_file("./benches/x100.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/x100.json", bench, StringCacheMode::All);
 }
 
 fn python_parse_string_array_unique_not_cached(bench: &mut Bencher) {
-    _python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::None);
+    python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::None);
 }
 
 fn python_parse_string_array_unique(bench: &mut Bencher) {
-    _python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::All);
 }
 
 fn python_parse_true_object(bench: &mut Bencher) {
-    _python_parse_file("./benches/true_object.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/true_object.json", bench, StringCacheMode::All);
 }
 
 /// Note - caching strings should make no difference here
 fn python_parse_true_array(bench: &mut Bencher) {
-    _python_parse_file("./benches/true_array.json", bench, StringCacheMode::All);
+    python_parse_file("./benches/true_array.json", bench, StringCacheMode::All);
 }
 
 benchmark_group!(
diff --git a/crates/jiter/src/number_decoder.rs b/crates/jiter/src/number_decoder.rs
@@ -83,7 +83,7 @@ impl AbstractNumberDecoder for NumberFloat {
         if !positive {
             // we started with a minus sign, so the first digit is at index + 1
             index += 1;
-        };
+        }
         let first2 = if positive { Some(&first) } else { data.get(index) };
 
         if let Some(digit) = first2 {
@@ -210,7 +210,7 @@ impl IntParse {
         if !positive {
             // we started with a minus sign, so the first digit is at index + 1
             index += 1;
-        };
+        }
         let first2 = if positive { Some(&first) } else { data.get(index) };
         let first_value = match first2 {
             Some(b'0') => {
@@ -425,7 +425,7 @@ impl AbstractNumberDecoder for NumberRange {
         if !positive {
             // we started with a minus sign, so the first digit is at index + 1
             index += 1;
-        };
+        }
 
         match data.get(index) {
             Some(b'0') => {
@@ -453,7 +453,7 @@ impl AbstractNumberDecoder for NumberRange {
             Some(digit) if (b'1'..=b'9').contains(digit) => (),
             Some(_) => return json_err!(InvalidNumber, index),
             None => return json_err!(EofWhileParsingValue, index),
-        };
+        }
 
         index += 1;
         for _ in 0..18 {
@@ -511,13 +511,13 @@ fn consume_exponential(data: &[u8], mut index: usize) -> JsonResult<usize> {
         Some(v) if v.is_ascii_digit() => (),
         Some(_) => return json_err!(InvalidNumber, index),
         None => return json_err!(EofWhileParsingValue, index),
-    };
+    }
 
     match data.get(index) {
         Some(v) if v.is_ascii_digit() => (),
         Some(_) => return json_err!(InvalidNumber, index),
         None => return json_err!(EofWhileParsingValue, index),
-    };
+    }
     index += 1;
 
     while let Some(next) = data.get(index) {
@@ -536,7 +536,7 @@ fn consume_decimal(data: &[u8], mut index: usize) -> JsonResult<usize> {
         Some(v) if v.is_ascii_digit() => (),
         Some(_) => return json_err!(InvalidNumber, index),
         None => return json_err!(EofWhileParsingValue, index),
-    };
+    }
     index += 1;
 
     while let Some(next) = data.get(index) {
diff --git a/crates/jiter/src/value.rs b/crates/jiter/src/value.rs
@@ -397,7 +397,7 @@ fn take_value_recursive<'j, 's>(
                                 }
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
-                            };
+                            }
                             Ok(JsonValue::empty_array())
                         }
                         Peek::Object => {
@@ -412,7 +412,7 @@ fn take_value_recursive<'j, 's>(
                                 },
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
-                            };
+                            }
                             Ok(JsonValue::empty_object())
                         }
                         _ => parser
@@ -444,7 +444,7 @@ fn take_value_recursive<'j, 's>(
                                 }
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
-                            };
+                            }
 
                             let RecursedValue::Array(mut array) = current_recursion else {
                                 unreachable!("known to be in array recursion");
@@ -482,7 +482,7 @@ fn take_value_recursive<'j, 's>(
                                 }
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
-                            };
+                            }
                             Ok(JsonValue::empty_array())
                         }
                         Peek::Object => {
@@ -497,7 +497,7 @@ fn take_value_recursive<'j, 's>(
                                 },
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
-                            };
+                            }
                             Ok(JsonValue::empty_object())
                         }
                         _ => parser
@@ -534,7 +534,7 @@ fn take_value_recursive<'j, 's>(
                                         }
                                         Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                         _ => (),
-                                    };
+                                    }
                                 }
                                 Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),
                                 _ => (),
@@ -712,7 +712,7 @@ fn take_value_skip_recursive(
                         }
                     })?;
             }
-        };
+        }
 
         // now try to advance position in the current array or object
         peek = loop {
diff --git a/crates/jiter/tests/main.rs b/crates/jiter/tests/main.rs
diff --git a/crates/jiter/tests/python.rs b/crates/jiter/tests/python.rs

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ fn jiter_value(path: &str, bench: &mut Bencher) {`
`20`	`20`	`bench.iter(\|\| {`
`21`	`21`	`let v = JsonValue::parse(black_box(json_data), false).unwrap();`
`22`	`22`	`black_box(v)`
`23`		`- })`
	`23`	`+ });`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`fn jiter_skip(path: &str, bench: &mut Bencher) {`
`@@ -29,7 +29,7 @@ fn jiter_skip(path: &str, bench: &mut Bencher) {`
`29`	`29`	`bench.iter(\|\| {`
`30`	`30`	`let mut jiter = Jiter::new(json_data);`
`31`	`31`	`jiter.next_skip().unwrap();`
`32`		`- })`
	`32`	`+ });`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`fn jiter_iter_big(path: &str, bench: &mut Bencher) {`
`@@ -52,7 +52,7 @@ fn jiter_iter_big(path: &str, bench: &mut Bencher) {`
`52`	`52`	`break;`
`53`	`53`	`}`
`54`	`54`	`}`
`55`		`- })`
	`55`	`+ });`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`fn find_string(jiter: &mut Jiter) -> String {`
`@@ -77,7 +77,7 @@ fn jiter_iter_pass2(path: &str, bench: &mut Bencher) {`
`77`	`77`	`let string = find_string(&mut jiter);`
`78`	`78`	`jiter.finish().unwrap();`
`79`	`79`	`black_box(string)`
`80`		`- })`
	`80`	`+ });`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`fn jiter_iter_string_array(path: &str, bench: &mut Bencher) {`
`@@ -94,7 +94,7 @@ fn jiter_iter_string_array(path: &str, bench: &mut Bencher) {`
`94`	`94`	`black_box(i.len());`
`95`	`95`	`}`
`96`	`96`	`jiter.finish().unwrap();`
`97`		`- })`
	`97`	`+ });`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`fn jiter_iter_true_array(path: &str, bench: &mut Bencher) {`
`@@ -109,7 +109,7 @@ fn jiter_iter_true_array(path: &str, bench: &mut Bencher) {`
`109`	`109`	`let i = jiter.known_bool(peek).unwrap();`
`110`	`110`	`black_box(i);`
`111`	`111`	`}`
`112`		`- })`
	`112`	`+ });`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`fn jiter_iter_true_object(path: &str, bench: &mut Bencher) {`
`@@ -127,7 +127,7 @@ fn jiter_iter_true_object(path: &str, bench: &mut Bencher) {`
`127`	`127`	`black_box((key, value));`
`128`	`128`	`}`
`129`	`129`	`}`
`130`		`- })`
	`130`	`+ });`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`fn jiter_iter_ints_array(path: &str, bench: &mut Bencher) {`
`@@ -142,7 +142,7 @@ fn jiter_iter_ints_array(path: &str, bench: &mut Bencher) {`
`142`	`142`	`let i = jiter.known_int(peek).unwrap();`
`143`	`143`	`black_box(i);`
`144`	`144`	`}`
`145`		`- })`
	`145`	`+ });`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`fn jiter_iter_floats_array(path: &str, bench: &mut Bencher) {`
`@@ -157,7 +157,7 @@ fn jiter_iter_floats_array(path: &str, bench: &mut Bencher) {`
`157`	`157`	`let i = jiter.known_float(peek).unwrap();`
`158`	`158`	`black_box(i);`
`159`	`159`	`}`
`160`		`- })`
	`160`	`+ });`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`fn jiter_string(path: &str, bench: &mut Bencher) {`
`@@ -168,7 +168,7 @@ fn jiter_string(path: &str, bench: &mut Bencher) {`
`168`	`168`	`let string = jiter.next_str().unwrap();`
`169`	`169`	`black_box(string);`
`170`	`170`	`jiter.finish().unwrap();`
`171`		`- })`
	`171`	`+ });`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`fn serde_value(path: &str, bench: &mut Bencher) {`
`@@ -177,7 +177,7 @@ fn serde_value(path: &str, bench: &mut Bencher) {`
`177`	`177`	`bench.iter(\|\| {`
`178`	`178`	`let value: Value = serde_json::from_slice(json_data).unwrap();`
`179`	`179`	`black_box(value);`
`180`		`- })`
	`180`	`+ });`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`fn serde_str(path: &str, bench: &mut Bencher) {`
`@@ -186,7 +186,7 @@ fn serde_str(path: &str, bench: &mut Bencher) {`
`186`	`186`	`bench.iter(\|\| {`
`187`	`187`	`let value: String = serde_json::from_slice(json_data).unwrap();`
`188`	`188`	`black_box(value);`
`189`		`- })`
	`189`	`+ });`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`macro_rules! test_cases {`
`@@ -260,7 +260,7 @@ fn string_array_jiter_value_owned(bench: &mut Bencher) {`
`260`	`260`	`bench.iter(\|\| {`
`261`	`261`	`let v = JsonValue::parse_owned(black_box(json_data), false, PartialMode::Off).unwrap();`
`262`	`262`	`black_box(v)`
`263`		`- })`
	`263`	`+ });`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`fn medium_response_jiter_value_owned(bench: &mut Bencher) {`
`@@ -269,7 +269,7 @@ fn medium_response_jiter_value_owned(bench: &mut Bencher) {`
`269`	`269`	`bench.iter(\|\| {`
`270`	`270`	`let v = JsonValue::parse_owned(black_box(json_data), false, PartialMode::Off).unwrap();`
`271`	`271`	`black_box(v)`
`272`		`- })`
	`272`	`+ });`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`fn x100_serde_iter(bench: &mut Bencher) {`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ fn python_parse_numeric(bench: &mut Bencher) {`
`18`	`18`	`)`
`19`	`19`	`.unwrap()`
`20`	`20`	`});`
`21`		`- })`
	`21`	`+ });`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`fn python_parse_other(bench: &mut Bencher) {`
`@@ -29,10 +29,10 @@ fn python_parse_other(bench: &mut Bencher) {`
`29`	`29`	`.python_parse(py, br#"["string", true, false, null]"#)`
`30`	`30`	`.unwrap()`
`31`	`31`	`});`
`32`		`- })`
	`32`	`+ });`
`33`	`33`	`}`
`34`	`34`
`35`		`-fn _python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMode) {`
	`35`	`+fn python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMode) {`
`36`	`36`	`let mut file = File::open(path).unwrap();`
`37`	`37`	`let mut contents = String::new();`
`38`	`38`	`file.read_to_string(&mut contents).unwrap();`
`@@ -48,56 +48,56 @@ fn _python_parse_file(path: &str, bench: &mut Bencher, cache_mode: StringCacheMo`
`48`	`48`	`.python_parse(py, json_data)`
`49`	`49`	`.unwrap()`
`50`	`50`	`});`
`51`		`- })`
	`51`	`+ });`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`fn python_parse_massive_ints_array(bench: &mut Bencher) {`
`55`		`- _python_parse_file("./benches/massive_ints_array.json", bench, StringCacheMode::All);`
	`55`	`+ python_parse_file("./benches/massive_ints_array.json", bench, StringCacheMode::All);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`fn python_parse_medium_response_not_cached(bench: &mut Bencher) {`
`59`		`- _python_parse_file("./benches/medium_response.json", bench, StringCacheMode::None);`
	`59`	`+ python_parse_file("./benches/medium_response.json", bench, StringCacheMode::None);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`fn python_parse_medium_response(bench: &mut Bencher) {`
`63`		`- _python_parse_file("./benches/medium_response.json", bench, StringCacheMode::All);`
	`63`	`+ python_parse_file("./benches/medium_response.json", bench, StringCacheMode::All);`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`fn python_parse_true_object_not_cached(bench: &mut Bencher) {`
`67`		`- _python_parse_file("./benches/true_object.json", bench, StringCacheMode::None);`
	`67`	`+ python_parse_file("./benches/true_object.json", bench, StringCacheMode::None);`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`fn python_parse_string_array_not_cached(bench: &mut Bencher) {`
`71`		`- _python_parse_file("./benches/string_array.json", bench, StringCacheMode::None);`
	`71`	`+ python_parse_file("./benches/string_array.json", bench, StringCacheMode::None);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`fn python_parse_string_array(bench: &mut Bencher) {`
`75`		`- _python_parse_file("./benches/string_array.json", bench, StringCacheMode::All);`
	`75`	`+ python_parse_file("./benches/string_array.json", bench, StringCacheMode::All);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`fn python_parse_x100_not_cached(bench: &mut Bencher) {`
`79`		`- _python_parse_file("./benches/x100.json", bench, StringCacheMode::None);`
	`79`	`+ python_parse_file("./benches/x100.json", bench, StringCacheMode::None);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`fn python_parse_x100(bench: &mut Bencher) {`
`83`		`- _python_parse_file("./benches/x100.json", bench, StringCacheMode::All);`
	`83`	`+ python_parse_file("./benches/x100.json", bench, StringCacheMode::All);`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`fn python_parse_string_array_unique_not_cached(bench: &mut Bencher) {`
`87`		`- _python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::None);`
	`87`	`+ python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::None);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`fn python_parse_string_array_unique(bench: &mut Bencher) {`
`91`		`- _python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::All);`
	`91`	`+ python_parse_file("./benches/string_array_unique.json", bench, StringCacheMode::All);`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`fn python_parse_true_object(bench: &mut Bencher) {`
`95`		`- _python_parse_file("./benches/true_object.json", bench, StringCacheMode::All);`
	`95`	`+ python_parse_file("./benches/true_object.json", bench, StringCacheMode::All);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/// Note - caching strings should make no difference here`
`99`	`99`	`fn python_parse_true_array(bench: &mut Bencher) {`
`100`		`- _python_parse_file("./benches/true_array.json", bench, StringCacheMode::All);`
	`100`	`+ python_parse_file("./benches/true_array.json", bench, StringCacheMode::All);`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`benchmark_group!(`
Original file line number	Diff line number	Diff line change
`@@ -397,7 +397,7 @@ fn take_value_recursive<'j, 's>(`
`397`	`397`	`}`
`398`	`398`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`399`	`399`	`_ => (),`
`400`		`- };`
	`400`	`+ }`
`401`	`401`	`Ok(JsonValue::empty_array())`
`402`	`402`	`}`
`403`	`403`	`Peek::Object => {`
`@@ -412,7 +412,7 @@ fn take_value_recursive<'j, 's>(`
`412`	`412`	`},`
`413`	`413`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`414`	`414`	`_ => (),`
`415`		`- };`
	`415`	`+ }`
`416`	`416`	`Ok(JsonValue::empty_object())`
`417`	`417`	`}`
`418`	`418`	`_ => parser`
`@@ -444,7 +444,7 @@ fn take_value_recursive<'j, 's>(`
`444`	`444`	`}`
`445`	`445`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`446`	`446`	`_ => (),`
`447`		`- };`
	`447`	`+ }`
`448`	`448`
`449`	`449`	`let RecursedValue::Array(mut array) = current_recursion else {`
`450`	`450`	`unreachable!("known to be in array recursion");`
`@@ -482,7 +482,7 @@ fn take_value_recursive<'j, 's>(`
`482`	`482`	`}`
`483`	`483`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`484`	`484`	`_ => (),`
`485`		`- };`
	`485`	`+ }`
`486`	`486`	`Ok(JsonValue::empty_array())`
`487`	`487`	`}`
`488`	`488`	`Peek::Object => {`
`@@ -497,7 +497,7 @@ fn take_value_recursive<'j, 's>(`
`497`	`497`	`},`
`498`	`498`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`499`	`499`	`_ => (),`
`500`		`- };`
	`500`	`+ }`
`501`	`501`	`Ok(JsonValue::empty_object())`
`502`	`502`	`}`
`503`	`503`	`_ => parser`
`@@ -534,7 +534,7 @@ fn take_value_recursive<'j, 's>(`
`534`	`534`	`}`
`535`	`535`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`536`	`536`	`_ => (),`
`537`		`- };`
	`537`	`+ }`
`538`	`538`	`}`
`539`	`539`	`Err(e) if !(partial_active && e.allowed_if_partial()) => return Err(e),`
`540`	`540`	`_ => (),`
`@@ -712,7 +712,7 @@ fn take_value_skip_recursive(`
`712`	`712`	`}`
`713`	`713`	`})?;`
`714`	`714`	`}`
`715`		`- };`
	`715`	`+ }`
`716`	`716`
`717`	`717`	`// now try to advance position in the current array or object`
`718`	`718`	`peek = loop {`