Add lint to suggest as_chunks over chunks_exact with constant

Suggest using slice.as_chunks::<N>() when chunks_exact(N) is called with a compile-time constant. This provides better ergonomics and type safety.

Fixes #15882

Author: rommeld

CHANGELOG.md

@@ -6252,6 +6252,7 @@ Released 2018-09-13
 [`chars_last_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_last_cmp
 [`chars_next_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_next_cmp
 [`checked_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions
+[`chunks_exact_to_as_chunks`]: https://rust-lang.github.io/rust-clippy/master/index.html#chunks_exact_to_as_chunks
 [`clear_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#clear_with_drain
 [`clone_double_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref
 [`clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy

clippy_lints/src/declared_lints.rs

@@ -352,6 +352,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS_INFO,
     crate::methods::CHARS_LAST_CMP_INFO,
     crate::methods::CHARS_NEXT_CMP_INFO,
+    crate::methods::CHUNKS_EXACT_TO_AS_CHUNKS_INFO,
     crate::methods::CLEAR_WITH_DRAIN_INFO,
     crate::methods::CLONED_INSTEAD_OF_COPIED_INFO,
     crate::methods::CLONE_ON_COPY_INFO,

clippy_lints/src/methods/chunks_exact_to_as_chunks.rs

@@ -0,0 +1,47 @@
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::msrvs::{self, Msrv};
+use rustc_hir::Expr;
+use rustc_lint::LateContext;
+
+use super::CHUNKS_EXACT_TO_AS_CHUNKS;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    recv: &Expr<'_>,
+    arg: &Expr<'_>,
+    method_name: &str,
+    msrv: &Msrv,
+) {
+    // Check for Rust version
+    if !msrv.meets(cx, msrvs::AS_CHUNKS) {
+        return;
+    }
+
+    // Check receiver is slice or array type
+    let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs();
+    if !recv_ty.is_slice() && !recv_ty.is_array() {
+        return;
+    }
+
+    // Check if argument is a constant
+    let constant_eval = ConstEvalCtxt::new(cx);
+    if let Some(Constant::Int(chunk_size)) = constant_eval.eval(arg) {
+        // Emit the lint
+        let suggestion = if method_name == "chunks_exact_mut" {
+            "as_chunks_mut"
+        } else {
+            "as_chunks"
+        };
+
+        span_lint_and_help(
+            cx,
+            CHUNKS_EXACT_TO_AS_CHUNKS,
+            expr.span,
+            format!("using `{method_name}` with a constant chunk size"),
+            None,
+            format!("consider using `{suggestion}::<{chunk_size}>()` for better ergonomics"),
+        );
+    }
+}

clippy_lints/src/methods/mod.rs

@@ -9,6 +9,7 @@ mod chars_last_cmp;
 mod chars_last_cmp_with_unwrap;
 mod chars_next_cmp;
 mod chars_next_cmp_with_unwrap;
+mod chunks_exact_to_as_chunks;
 mod clear_with_drain;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
@@ -2088,6 +2089,32 @@ declare_clippy_lint! {
     "replace `.bytes().nth()` with `.as_bytes().get()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `chunks_exact` or `chunks_exact_mut` with a constant chunk size.
+    ///
+    /// ### Why is this bad?
+    /// `as_chunks` provides better ergonomics and type safety by returning arrays instead of slices.
+    /// It was stabilized in Rust 1.88.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let slice = [1, 2, 3, 4, 5, 6];
+    /// let mut it = slice.chunks_exact(2);
+    /// for chunk in it {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let slice = [1, 2, 3, 4, 5, 6];
+    /// let (chunks, remainder) = slice.as_chunks::<2>();
+    /// for chunk in chunks {}
+    /// ```
+    #[clippy::version = "1.93.0"]
+    pub CHUNKS_EXACT_TO_AS_CHUNKS,
+    style,
+    "using `chunks_exact` with constant when `as_chunks` is more ergonomic"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
@@ -5725,6 +5752,9 @@ impl Methods {
                         unwrap_expect_used::Variant::Unwrap,
                     );
                 },
+                (name, [arg]) if matches!(name.as_str(), "chunks_exact" | "chunks_exact_mut") => {
+                    chunks_exact_to_as_chunks::check(cx, expr, recv, arg, name.as_str(), &self.msrv);
+                },
                 _ => {},
             }
         }

clippy_utils/src/msrvs.rs

@@ -23,7 +23,7 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
-    1,88,0 { LET_CHAINS }
+    1,88,0 { LET_CHAINS, AS_CHUNKS }
     1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT, CONST_CHAR_IS_DIGIT, UNSIGNED_IS_MULTIPLE_OF, INTEGER_SIGN_CAST }
     1,85,0 { UINT_FLOAT_MIDPOINT, CONST_SIZE_OF_VAL }
     1,84,0 { CONST_OPTION_AS_SLICE, MANUAL_DANGLING_PTR }

tests/ui/chunks_exact_to_as_chunks.rs

@@ -0,0 +1,34 @@
+#![warn(clippy::chunks_exact_to_as_chunks)]
+#![allow(unused)]
+
+fn main() {
+    let slice = [1, 2, 3, 4, 5, 6, 7, 8];
+
+    // Should trigger lint - literal constant
+    let mut it = slice.chunks_exact(4);
+    //~^ ERROR: using `chunks_exact` with a constant chunk size
+    for chunk in it {}
+
+    // Should trigger lint - const value
+    const CHUNK_SIZE: usize = 4;
+    let mut it = slice.chunks_exact(CHUNK_SIZE);
+    //~^ ERROR: using `chunks_exact` with a constant chunk size
+    for chunk in it {}
+
+    // Should NOT trigger - runtime value
+    let size = 4;
+    let mut it = slice.chunks_exact(size);
+    for chunk in it {}
+
+    // Should trigger lint - with remainder
+    let mut it = slice.chunks_exact(3);
+    //~^ ERROR: using `chunks_exact` with a constant chunk size
+    for chunk in &mut it {}
+    for e in it.remainder() {}
+
+    // Should trigger - mutable variant
+    let mut arr = [1, 2, 3, 4, 5, 6, 7, 8];
+    let mut it = arr.chunks_exact_mut(4);
+    //~^ ERROR: using `chunks_exact_mut` with a constant chunk size
+    for chunk in it {}
+}

tests/ui/chunks_exact_to_as_chunks.stderr

@@ -0,0 +1,36 @@
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_to_as_chunks.rs:8:18
+   |
+LL |     let mut it = slice.chunks_exact(4);
+   |                  ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `as_chunks::<4>()` for better ergonomics
+   = note: `-D clippy::chunks-exact-to-as-chunks` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::chunks_exact_to_as_chunks)]`
+
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_to_as_chunks.rs:14:18
+   |
+LL |     let mut it = slice.chunks_exact(CHUNK_SIZE);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `as_chunks::<4>()` for better ergonomics
+
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_to_as_chunks.rs:24:18
+   |
+LL |     let mut it = slice.chunks_exact(3);
+   |                  ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `as_chunks::<3>()` for better ergonomics
+
+error: using `chunks_exact_mut` with a constant chunk size
+  --> tests/ui/chunks_exact_to_as_chunks.rs:31:18
+   |
+LL |     let mut it = arr.chunks_exact_mut(4);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `as_chunks_mut::<4>()` for better ergonomics
+
+error: aborting due to 4 previous errors
+