Add lint to suggest as_chunks over chunks_exact with constant

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_with_const_size`]: https://rust-lang.github.io/rust-clippy/master/index.html#chunks_exact_with_const_size
 [`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_WITH_CONST_SIZE_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_with_const_size.rs

@@ -0,0 +1,110 @@
+use super::CHUNKS_EXACT_WITH_CONST_SIZE;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::ForLoop;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::visitors::is_const_evaluatable;
+use clippy_utils::{expr_use_ctxt, get_parent_expr, sym};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, Node, PatKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty;
+use rustc_span::{Span, Symbol};
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    recv: &'tcx Expr<'tcx>,
+    arg: &'tcx Expr<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    call_span: Span,
+    method_name: Symbol,
+    msrv: Msrv,
+) {
+    let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
+    if !matches!(recv_ty.kind(), ty::Ref(_, inner, _) if inner.is_slice()) {
+        return;
+    }
+
+    if is_const_evaluatable(cx, arg) {
+        if !msrv.meets(cx, msrvs::AS_CHUNKS) {
+            return;
+        }
+
+        let suggestion_method = if method_name == sym::chunks_exact_mut {
+            "as_chunks_mut"
+        } else {
+            "as_chunks"
+        };
+
+        let mut applicability = Applicability::MachineApplicable;
+        let arg_str = snippet_with_context(cx, arg.span, expr.span.ctxt(), "_", &mut applicability).0;
+
+        let as_chunks = format_args!("{suggestion_method}::<{arg_str}>()");
+
+        span_lint_and_then(
+            cx,
+            CHUNKS_EXACT_WITH_CONST_SIZE,
+            call_span,
+            format!("using `{method_name}` with a constant chunk size"),
+            |diag| {
+                let use_ctxt = expr_use_ctxt(cx, expr);
+
+                let in_for_loop = {
+                    let mut cur_expr = expr;
+                    loop {
+                        if let Some(parent_expr) = get_parent_expr(cx, cur_expr) {
+                            if let Some(for_loop) = ForLoop::hir(parent_expr)
+                                && for_loop.arg.hir_id == expr.hir_id
+                            {
+                                break true;
+                            }
+                            cur_expr = parent_expr;
+                        } else {
+                            break false;
+                        }
+                    }
+                };
+
+                let is_iterator_method = if let Node::Expr(parent_expr) = use_ctxt.node
+                    && let ExprKind::MethodCall(_, receiver, _, _) = parent_expr.kind
+                    && receiver.hir_id == use_ctxt.child_id
+                    && let Some(method_did) = cx.typeck_results().type_dependent_def_id(parent_expr.hir_id)
+                    && let Some(trait_did) = cx.tcx.trait_of_assoc(method_did)
+                {
+                    matches!(
+                        cx.tcx.get_diagnostic_name(trait_did),
+                        Some(sym::Iterator | sym::IntoIterator)
+                    )
+                } else {
+                    false
+                };
+
+                if in_for_loop {
+                    diag.span_suggestion(
+                        call_span,
+                        "consider using `as_chunks` instead",
+                        format!("{as_chunks}.0"),
+                        applicability,
+                    );
+                } else if is_iterator_method {
+                    diag.span_suggestion(
+                        call_span,
+                        "consider using `as_chunks` instead",
+                        format!("{as_chunks}.0.iter()"),
+                        applicability,
+                    );
+                } else {
+                    diag.span_help(call_span, format!("consider using `{as_chunks}` instead"));
+
+                    if let Node::LetStmt(let_stmt) = use_ctxt.node
+                        && let PatKind::Binding(_, _, ident, _) = let_stmt.pat.kind
+                    {
+                        diag.note(format!(
+                            "you can access the chunks using `{ident}.0.iter()`, and the remainder using `{ident}.1`"
+                        ));
+                    }
+                }
+            },
+        );
+    }
+}

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_with_const_size;
 mod clear_with_drain;
 mod clone_on_copy;
 mod clone_on_ref_ptr;
@@ -2087,6 +2088,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_WITH_CONST_SIZE,
+    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.
@@ -4787,6 +4814,7 @@ impl_lint_pass!(Methods => [
     ITER_NTH,
     ITER_NTH_ZERO,
     BYTES_NTH,
+    CHUNKS_EXACT_WITH_CONST_SIZE,
     ITER_SKIP_NEXT,
     GET_UNWRAP,
     GET_LAST_WITH_LEN,
@@ -5043,6 +5071,9 @@ impl Methods {
                         _ => {},
                     }
                 },
+                (name @ (sym::chunks_exact | sym::chunks_exact_mut), [arg]) => {
+                    chunks_exact_with_const_size::check(cx, recv, arg, expr, call_span, name, self.msrv);
+                },
                 (sym::and_then, [arg]) => {
                     let biom_option_linted = bind_instead_of_map::check_and_then_some(cx, expr, recv, arg);
                     let biom_result_linted = bind_instead_of_map::check_and_then_ok(cx, expr, recv, arg);

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 }

clippy_utils/src/sym.rs

@@ -111,6 +111,8 @@ generate! {
     checked_pow,
     checked_rem_euclid,
     checked_sub,
+    chunks_exact,
+    chunks_exact_mut,
     clamp,
     clippy_utils,
     clone_into,

tests/ui/chunks_exact_with_const_size.fixed

@@ -0,0 +1,45 @@
+#![warn(clippy::chunks_exact_with_const_size)]
+#![allow(unused)]
+
+fn main() {
+    let slice = [1, 2, 3, 4, 5, 6, 7, 8];
+
+    // Should NOT trigger - runtime value
+    let size = 4;
+    let mut it = slice.chunks_exact(size);
+    for chunk in it {}
+
+    // Should trigger - direct iteration without binding (gets suggestion)
+    for chunk in slice.as_chunks::<4>().0 {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - direct iteration with const
+    const CHUNK_SIZE: usize = 4;
+    for chunk in slice.as_chunks::<CHUNK_SIZE>().0 {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - chunks_exact_mut with direct iteration (gets suggestion without .iter())
+    let mut arr = [1, 2, 3, 4, 5, 6, 7, 8];
+    for chunk in arr.as_chunks_mut::<4>().0 {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - used with iterator method (not for loop, so needs .iter())
+    let _: Vec<_> = slice.as_chunks::<4>().0.iter().collect();
+    //~^ chunks_exact_with_const_size
+
+    // Should NOT trigger - macro-expanded sizes are not recognized as const by is_const_evaluatable
+    macro_rules! chunk_size {
+        () => {
+            4
+        };
+    }
+    for chunk in slice.chunks_exact(chunk_size!()) {
+        let _ = chunk;
+    }
+}

tests/ui/chunks_exact_with_const_size.rs

@@ -0,0 +1,45 @@
+#![warn(clippy::chunks_exact_with_const_size)]
+#![allow(unused)]
+
+fn main() {
+    let slice = [1, 2, 3, 4, 5, 6, 7, 8];
+
+    // Should NOT trigger - runtime value
+    let size = 4;
+    let mut it = slice.chunks_exact(size);
+    for chunk in it {}
+
+    // Should trigger - direct iteration without binding (gets suggestion)
+    for chunk in slice.chunks_exact(4) {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - direct iteration with const
+    const CHUNK_SIZE: usize = 4;
+    for chunk in slice.chunks_exact(CHUNK_SIZE) {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - chunks_exact_mut with direct iteration (gets suggestion without .iter())
+    let mut arr = [1, 2, 3, 4, 5, 6, 7, 8];
+    for chunk in arr.chunks_exact_mut(4) {
+        //~^ chunks_exact_with_const_size
+        let _ = chunk;
+    }
+
+    // Should trigger - used with iterator method (not for loop, so needs .iter())
+    let _: Vec<_> = slice.chunks_exact(4).collect();
+    //~^ chunks_exact_with_const_size
+
+    // Should NOT trigger - macro-expanded sizes are not recognized as const by is_const_evaluatable
+    macro_rules! chunk_size {
+        () => {
+            4
+        };
+    }
+    for chunk in slice.chunks_exact(chunk_size!()) {
+        let _ = chunk;
+    }
+}

tests/ui/chunks_exact_with_const_size.stderr

@@ -0,0 +1,29 @@
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_with_const_size.rs:13:24
+   |
+LL |     for chunk in slice.chunks_exact(4) {
+   |                        ^^^^^^^^^^^^^^^ help: consider using `as_chunks` instead: `as_chunks::<4>().0`
+   |
+   = note: `-D clippy::chunks-exact-with-const-size` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::chunks_exact_with_const_size)]`
+
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_with_const_size.rs:20:24
+   |
+LL |     for chunk in slice.chunks_exact(CHUNK_SIZE) {
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `as_chunks` instead: `as_chunks::<CHUNK_SIZE>().0`
+
+error: using `chunks_exact_mut` with a constant chunk size
+  --> tests/ui/chunks_exact_with_const_size.rs:27:22
+   |
+LL |     for chunk in arr.chunks_exact_mut(4) {
+   |                      ^^^^^^^^^^^^^^^^^^^ help: consider using `as_chunks` instead: `as_chunks_mut::<4>().0`
+
+error: using `chunks_exact` with a constant chunk size
+  --> tests/ui/chunks_exact_with_const_size.rs:33:27
+   |
+LL |     let _: Vec<_> = slice.chunks_exact(4).collect();
+   |                           ^^^^^^^^^^^^^^^ help: consider using `as_chunks` instead: `as_chunks::<4>().0.iter()`
+
+error: aborting due to 4 previous errors
+

tests/ui/chunks_exact_with_const_size_unfixable.rs

@@ -0,0 +1,52 @@
+#![warn(clippy::chunks_exact_with_const_size)]
+#![allow(unused)]
+#![allow(clippy::iter_cloned_collect)]
+
+fn main() {
+    let slice = [1, 2, 3, 4, 5, 6, 7, 8];
+    const CHUNK_SIZE: usize = 4;
+
+    // Should trigger lint - literal constant (stored in let binding, so help not suggestion)
+    let result = slice.chunks_exact(4);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger lint - const value
+    let result = slice.chunks_exact(CHUNK_SIZE);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger lint - simple iteration
+    let result = slice.chunks_exact(3);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger - mutable variant
+    let mut arr = [1, 2, 3, 4, 5, 6, 7, 8];
+    let result = arr.chunks_exact_mut(4);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger - multiline expression
+    #[rustfmt::skip]
+    let result = slice
+        .iter()
+        .copied()
+        .collect::<Vec<_>>()
+        .chunks_exact(2);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger - array coerces to slice reference
+    let array = [1, 2, 3, 4, 5, 6, 7, 8];
+    let result = array.chunks_exact(4);
+    //~^ chunks_exact_with_const_size
+
+    // Should trigger lint with help message only (not suggestion) - stored in variable
+    let mut chunk_iter = slice.chunks_exact(CHUNK_SIZE);
+    //~^ chunks_exact_with_const_size
+    for chunk in chunk_iter.by_ref() {}
+    let _remainder = chunk_iter.remainder();
+
+    // Similar for mutable version - help message only
+    let mut arr2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let mut chunk_iter = arr2.chunks_exact_mut(CHUNK_SIZE);
+    //~^ chunks_exact_with_const_size
+    for chunk in chunk_iter.by_ref() {}
+    let _remainder = chunk_iter.into_remainder();
+}