CI(rust): Tighten clippy rules except for tests where we relax (#112)

Co-authored-by: Guillaume Mulocher <gmulocher@arista.com>

Author: ClausHolbechArista

Cargo.toml

@@ -27,32 +27,32 @@ lto = true
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
-missing_docs = "warn"
-missing_debug_implementations = "warn"
-unreachable_pub = "warn"
-unused_qualifications = "warn"
-deprecated = "warn"
+missing_docs = "deny"
+missing_debug_implementations = "deny"
+unreachable_pub = "deny"
+unused_qualifications = "deny"
+deprecated = "deny"
 semicolon_in_expressions_from_macros = "deny"
-rust_2024_compatibility = { level = "warn", priority = -1 }
+rust_2024_compatibility = { level = "deny", priority = -1 }
 
 [workspace.lints.clippy]
 # Pedantic group
-pedantic = { level = "warn", priority = -1 }
+pedantic = { level = "deny", priority = -1 }
 must_use_candidate = "allow"
 missing_errors_doc = "allow"
 missing_docs_in_private_items = "allow"
 
 # Restriction group
-allow_attributes_without_reason = "warn"
-as_conversions = "warn"
+allow_attributes_without_reason = "deny"
+as_conversions = "deny"
 create_dir = "deny"
 dbg_macro = "deny"
 empty_drop = "deny"
 empty_enum_variants_with_brackets = "deny"
 empty_structs_with_brackets = "deny"
 error_impl_error = "deny"
 exit = "deny"
-expect_used = "warn"
+expect_used = "deny"
 field_scoped_visibility_modifiers = "deny"
 filetype_is_file = "deny"
 float_cmp_const = "deny"
@@ -63,9 +63,9 @@ if_then_some_else_none = "deny"
 impl_trait_in_params = "deny"
 indexing_slicing = "deny"
 infinite_loop = "deny"
-integer_division_remainder_used = "warn"
-integer_division = "warn"
-iter_over_hash_type = "warn"
+integer_division_remainder_used = "deny"
+integer_division = "deny"
+iter_over_hash_type = "deny"
 lossy_float_literal = "deny"
 map_err_ignore = "deny"
 map_with_unused_argument_over_ranges = "deny"
@@ -76,43 +76,44 @@ module_name_repetitions = "deny"
 multiple_inherent_impl = "deny"
 multiple_unsafe_ops_per_block = "deny"
 needless_raw_strings = "deny"
-panic = "warn"
+panic = "deny"
 panic_in_result_fn = "deny"
 partial_pub_fields = "deny"
 pathbuf_init_then_push = "deny"
 print_stderr = "deny"
-print_stdout = "warn"
+print_stdout = "deny"
 pub_without_shorthand = "deny"
-redundant_type_annotations = "warn"
-ref_patterns = "allow"                        # TODO: discuss
+redundant_type_annotations = "deny"
+ref_patterns = "deny"
 renamed_function_params = "deny"
 rest_pat_in_fully_bound_structs = "deny"
 same_name_method = "deny"
 self_named_module_files = "deny"
-semicolon_inside_block = "allow"              # TODO: discuss
-semicolon_outside_block = "allow"             # TODO: discuss
-separated_literal_suffix = "allow"            # TODO: discuss
-shadow_reuse = "warn"
+semicolon_inside_block = "deny"
+semicolon_outside_block = "allow"
+separated_literal_suffix = "allow"
+shadow_same = "allow"
+shadow_reuse = "allow"
 shadow_unrelated = "deny"
 str_to_string = "deny"
 string_add = "allow"                          # TODO: discuss
-string_lit_chars_any = "warn"
-string_slice = "warn"
-suspicious_xor_used_as_pow = "warn"
+string_lit_chars_any = "deny"
+string_slice = "deny"
+suspicious_xor_used_as_pow = "deny"
 tests_outside_test_module = "deny"
 todo = "deny"
 try_err = "deny"
 undocumented_unsafe_blocks = "deny"
-unimplemented = "warn"
+unimplemented = "deny"
 unnecessary_safety_comment = "deny"
 unnecessary_safety_doc = "deny"
 unnecessary_self_imports = "deny"
-unneeded_field_pattern = "warn"
+unneeded_field_pattern = "deny"
 unreachable = "deny"
-unseparated_literal_suffix = "allow"          # TODO: discuss
+unseparated_literal_suffix = "deny"
 unused_result_ok = "deny"
 unused_trait_names = "deny"
-unwrap_in_result = "warn"
-unwrap_used = "allow"                         # TODO: discuss
-use_debug = "warn"
+unwrap_in_result = "deny"
+unwrap_used = "deny"
+use_debug = "deny"
 verbose_file_reads = "deny"

clippy.toml

@@ -0,0 +1,6 @@
+allow-dbg-in-tests = true
+allow-expect-in-tests = true
+allow-indexing-slicing-in-tests = true
+allow-panic-in-tests = true
+allow-print-in-tests = true
+allow-unwrap-in-tests = true

rust/yaml-parser/benches/parser_bench.rs

@@ -96,13 +96,21 @@ fn bench_saphyr_marked_parse(bench: &mut criterion::Bencher<'_>, input: &str) {
     });
 }
 
+#[expect(
+    clippy::unwrap_used,
+    reason = "benchmark corpora must remain valid serde_yaml input; panic preserves that precondition"
+)]
 fn bench_serde_yaml_value_parse(bench: &mut criterion::Bencher<'_>, input: &str) {
     bench.iter(|| {
         let value: serde_yaml::Value = serde_yaml::from_str(black_box(input)).unwrap();
         black_box(value);
     });
 }
 
+fn input_throughput(input: &str) -> Throughput {
+    Throughput::Bytes(u64::try_from(input.len()).unwrap_or(u64::MAX))
+}
+
 /// Benchmark parsing throughput for different document types.
 fn bench_parse_throughput(criterion: &mut Criterion) {
     let test_cases: &[(&str, &str)] = &[
@@ -118,7 +126,7 @@ fn bench_parse_throughput(criterion: &mut Criterion) {
     let mut group = criterion.benchmark_group("parse_throughput");
 
     for (name, input) in test_cases {
-        group.throughput(Throughput::Bytes(u64::try_from(input.len()).unwrap()));
+        group.throughput(input_throughput(input));
 
         // Benchmark yaml-parser (always includes spans)
         group.bench_with_input(
@@ -226,6 +234,10 @@ key3: "tab\there"
 /// Benchmark serde-based deserialization throughput for different document
 /// types when the `serde` feature is enabled.
 #[cfg(feature = "serde")]
+#[expect(
+    clippy::unwrap_used,
+    reason = "benchmark corpora must deserialize successfully; panic preserves that precondition"
+)]
 fn bench_serde_deserialize_throughput(criterion: &mut Criterion) {
     let test_cases: &[(&str, &str)] = &[
         ("large_mapping", LARGE_MAPPING),
@@ -243,7 +255,7 @@ fn bench_serde_deserialize_throughput(criterion: &mut Criterion) {
         // We expect both libraries to successfully deserialize all benchmark
         // corpora. If either panics here, that's a behavioural regression we
         // want to see rather than silently skipping the dataset.
-        group.throughput(Throughput::Bytes(u64::try_from(input.len()).unwrap()));
+        group.throughput(input_throughput(input));
 
         // Benchmark yaml-parser's serde-based deserialization into our own
         // generic `OwnedYamlValue` tree. This uses the crate's only serde

rust/yaml-parser/examples/profile_cases.rs

@@ -116,8 +116,15 @@ fn main() -> ExitCode {
         #[cfg(feature = "serde")]
         Mode::Serde => {
             for _ in 0..iterations {
-                let value: OwnedYamlValue = yaml_parser::serde::from_str(black_box(input)).unwrap();
-                black_box(value);
+                match yaml_parser::serde::from_str::<OwnedYamlValue>(black_box(input)) {
+                    Ok(value) => {
+                        black_box(value);
+                    }
+                    Err(error) => {
+                        eprintln!("serde deserialization failed for {dataset_arg}: {error}");
+                        return ExitCode::FAILURE;
+                    }
+                }
             }
         }
     }

rust/yaml-parser/src/emitter/document.rs

@@ -129,20 +129,14 @@ impl Emitter<'_> {
         self.tag_handles.insert("!!", "tag:yaml.org,2002:");
 
         let mut idx = self.pos;
-        loop {
-            let Some(continue_scan) = self.cursor.peek_with(idx, |token, _| match token {
-                Token::TagDirective(handle, prefix) => {
-                    self.tag_handles.insert(handle, prefix);
-                    true
-                }
-                Token::DocStart | Token::DocEnd => false,
-                _ => true,
-            }) else {
-                break;
-            };
-            if !continue_scan {
-                break;
+        while let Some(true) = self.cursor.peek_with(idx, |token, _| match token {
+            Token::TagDirective(handle, prefix) => {
+                self.tag_handles.insert(handle, prefix);
+                true
             }
+            Token::DocStart | Token::DocEnd => false,
+            _ => true,
+        }) {
             idx += 1;
         }
     }

rust/yaml-parser/src/emitter/trivia.rs

@@ -53,8 +53,7 @@ impl Emitter<'_> {
         loop {
             match self.peek_kind() {
                 Some(TokenKind::LineStart) => {
-                    let (token, span) = self.take_current().unwrap();
-                    let Token::LineStart(indent) = token else {
+                    let Some((Token::LineStart(indent), span)) = self.take_current() else {
                         debug_assert!(false, "expected LineStart token");
                         break;
                     };

rust/yaml-parser/src/lexer/mod.rs

@@ -30,10 +30,9 @@ mod trivia;
 
 #[cfg(test)]
 #[allow(
-    clippy::indexing_slicing,
     clippy::min_ident_chars,
     clippy::shadow_reuse,
-    reason = "Tests benefit from direct indexing, short identifiers, and variable shadowing for readability"
+    reason = "Tests benefit from short identifiers and variable shadowing for readability"
 )]
 mod tests;
 

rust/yaml-parser/src/lexer/properties.rs

@@ -91,7 +91,7 @@ impl<'input> Lexer<'input> {
             // Colon ends plain scalar if followed by whitespace (or EOF)
             if peek_ch == ':' {
                 let next = self.peek_n(1);
-                if next.is_none() || next.is_some_and(char::is_whitespace) {
+                if next.is_none_or(char::is_whitespace) {
                     break;
                 }
             }

rust/yaml-parser/src/lexer/quoted.rs

@@ -42,7 +42,10 @@ impl<'input> Lexer<'input> {
     fn finish_quoted_newline(&mut self) -> usize {
         // Consume newline
         let newline_start = self.byte_pos;
-        let ch = self.advance().unwrap();
+        let Some(ch) = self.advance() else {
+            debug_assert!(false, "finish_quoted_newline called at EOF");
+            return self.byte_pos;
+        };
         if ch == '\r' && self.peek() == Some('\n') {
             self.advance();
         }
@@ -220,7 +223,7 @@ impl<'input> Lexer<'input> {
         // Track the content length after the last non-escape character.
         // When we see a newline, we trim trailing whitespace but only up to this position.
         // This preserves escaped whitespace like \t while trimming literal trailing whitespace.
-        let mut escape_protected_len = 0usize;
+        let mut escape_protected_len = 0_usize;
 
         loop {
             match self.peek() {
@@ -310,6 +313,15 @@ impl<'input> Lexer<'input> {
         Some(result)
     }
 
+    fn ascii_hex_digit_value(ch: char) -> Option<u32> {
+        match ch {
+            '0'..='9' => Some(u32::from(ch) - u32::from('0')),
+            'a'..='f' => Some(u32::from(ch) - u32::from('a') + 10),
+            'A'..='F' => Some(u32::from(ch) - u32::from('A') + 10),
+            _ => None,
+        }
+    }
+
     #[allow(
         clippy::string_slice,
         reason = "self.byte_pos is always at proper UTF-8 boundaries"
@@ -320,12 +332,11 @@ impl<'input> Lexer<'input> {
             'u' => 4,
             _ => 8, // 'U' case
         };
-        let mut value = 0u32;
-        let mut consumed = 0u8;
+        let mut value = 0_u32;
+        let mut consumed = 0_u8;
         for _ in 0..digits {
             if let Some(peek_ch) = self.peek() {
-                if peek_ch.is_ascii_hexdigit() {
-                    let digit = peek_ch.to_digit(16).unwrap();
+                if let Some(digit) = Self::ascii_hex_digit_value(peek_ch) {
                     value = value * 16 + digit;
                     consumed += 1;
                     self.advance();

rust/yaml-parser/src/parser/tests.rs

@@ -1,10 +1,8 @@
-#![allow(clippy::indexing_slicing, reason = "panics are acceptable in tests")]
-#![allow(clippy::panic, reason = "panic is acceptable in tests")]
-#![allow(
 // Copyright (c) 2026 Arista Networks, Inc.
 // Use of this source code is governed by the Apache License 2.0
 // that can be found in the LICENSE file.
 
+#![allow(
     clippy::min_ident_chars,
     reason = "single-char closure params are fine in tests"
 )]
@@ -300,7 +298,6 @@ fn parse_via_events(input: &str) -> Vec<Node<'static>> {
 
 /// Test that parsing through collected events matches the public AST path.
 #[test]
-#[allow(clippy::print_stderr, reason = "Debug output on failure")]
 fn test_event_parser_matches_public_parse_pipeline() {
     let test_cases = [
         "hello",
@@ -522,7 +519,7 @@ fn test_invalid_explicit_builtin_tags_report_error_and_recover_to_string() {
         );
         let expected_text = input.split_once(' ').map_or("", |(_, text)| text);
         assert!(
-            matches!(docs[0].value, Value::String(ref text) if text.as_ref() == expected_text),
+            matches!(&docs[0].value, Value::String(text) if text == expected_text),
             "expected string recovery for {input:?}, got {:?}",
             docs[0].value
         );
@@ -557,7 +554,7 @@ fn test_non_specific_and_custom_tags_disable_implicit_resolution() {
         non_specific_errors.is_empty(),
         "unexpected errors: {non_specific_errors:?}"
     );
-    assert!(matches!(non_specific_docs[0].value, Value::String(ref text) if text == "42"));
+    assert!(matches!(&non_specific_docs[0].value, Value::String(text) if text == "42"));
     assert_eq!(
         non_specific_docs[0].tag().map(|tag| tag.value.as_ref()),
         Some("!")
@@ -568,7 +565,7 @@ fn test_non_specific_and_custom_tags_disable_implicit_resolution() {
         custom_errors.is_empty(),
         "unexpected errors: {custom_errors:?}"
     );
-    assert!(matches!(custom_docs[0].value, Value::String(ref text) if text == "42"));
+    assert!(matches!(&custom_docs[0].value, Value::String(text) if text == "42"));
     assert_eq!(
         custom_docs[0].tag().map(|tag| tag.value.as_ref()),
         Some("!custom")
@@ -579,7 +576,7 @@ fn test_non_specific_and_custom_tags_disable_implicit_resolution() {
         explicit_str_errors.is_empty(),
         "unexpected errors: {explicit_str_errors:?}"
     );
-    assert!(matches!(explicit_str_docs[0].value, Value::String(ref text) if text == "42"));
+    assert!(matches!(&explicit_str_docs[0].value, Value::String(text) if text == "42"));
 
     let (explicit_int_docs, explicit_int_errors) = parse("!<tag:yaml.org,2002:int> 0o52");
     assert!(