Add lint to suggest as_chunks over chunks_exact with constant #16002

rommeld · 2025-11-01T11:10:08Z

Adds a new lint chunks_exact_to_as_chunks that suggests using as_chunks instead of chunks_exact when the chunk size is a compile-time constant.

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

fixes #15882

rustbot · 2025-11-01T11:10:13Z

r? @Jarcho

rustbot has assigned @Jarcho.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

github-actions · 2025-11-01T11:19:44Z

Lintcheck changes for c50ccf8

Lint	Added	Removed	Changed
`clippy::chunks_exact_with_const_size`	9	0	0

This comment will be updated if you push new changes

ada4a

Good start:) Left a couple suggestions

View changes since this review

ada4a · 2025-11-04T15:15:13Z

tests/ui/chunks_exact_to_as_chunks.stderr

+LL |     let mut it = slice.chunks_exact(CHUNK_SIZE);
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `as_chunks::<4>()` for better ergonomics


As this example shows, the suggestion replace even named constants with their values. To fix that, build the suggestion using a snippet of arg, to preserve its textual representation:

- format!("consider using `{suggestion}::<{chunk_size}>()` for better ergonomics") + let arg_str = snippet(cx, arg.span, "_"); + format!("consider using `{suggestion}::<{arg_str}>()` for better ergonomics")

Done in 610acda

ada4a · 2025-11-04T15:16:08Z

tests/ui/chunks_exact_to_as_chunks.rs

+
+    // Should trigger lint - literal constant
+    let mut it = slice.chunks_exact(4);
+    //~^ ERROR: using `chunks_exact` with a constant chunk size


nit: you could also use the lint name, which is a bit shorter:

Suggested change

//~^ ERROR: using `chunks_exact` with a constant chunk size

//~^ chunks_exact_to_as_chunks

Done in 610acda

Oh, no, that's not what I meant.. sorry for not articulating myself clearly.

The error message by itself is great, no need to change it. It's just that in the ui-test file, you can specify the error annotation not only as //~^ ERROR: <error message>, but also as //~^ <lint_name> (in your case, //~^ chunks_exact_with_const_size, which makes the test suite much less verbose overall, and so that's the change I was proposing.

I guess I misunderstood, and I hope this hash is correctly implemented and suits your suggestion bc1d010.

Yes, that's exactly what I meant:)

ada4a · 2025-11-04T15:22:14Z

clippy_lints/src/methods/mod.rs

+    /// for chunk in chunks {}
+    /// ```
+    #[clippy::version = "1.93.0"]
+    pub CHUNKS_EXACT_TO_AS_CHUNKS,


lint names usually either point out the "bad" pattern used (e.g. ok_expect), or what the pattern could be replaced with (e.g. manual_map). I think yours could use the former scheme, and be called something like chunks_exact_with_const_size

Done in 610acda

ada4a · 2025-11-04T15:24:56Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+            "as_chunks"
+        };
+
+        span_lint_and_help(


This could be pretty effortlessly switched over to give suggestions, which are quite nice to have. https://doc.rust-lang.org/clippy/development/emitting_lints.html#suggestions-automatic-fixes should help you in that, but don't hesitate to ask if something's unclear

Done in 7082eef

Awesome, thank you!

ada4a · 2025-11-04T15:29:03Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+    // 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;
+    }


You want to check for types that can be adjusted to slices, which includes e.g. Vec. For that, you can use TyCtxt::expr_ty_adjusted:

Suggested change

// 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 receiver is slice-like

if !cx.typeck_results().expr_ty_adjusted(recv).peel_refs().is_slice() {

return;

}

Done in 1d99b91

ada4a · 2025-11-04T15:29:29Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+    // Check for Rust version
+    if !msrv.meets(cx, msrvs::AS_CHUNKS) {
+        return;
+    }


This check is somewhat expensive, so it's best to perform it towards the end, e.g. after the constant check

Done in 2731771

Sorry, I meant after the constant check, but before the lint emission -- currently, the check doesn't actually do anything 😅

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 rust-lang#15882

Changed example suggestion from const to snippet Shortend error message Followed clippy naming conventions

rustbot · 2025-11-04T18:38:05Z

This PR was rebased onto a different master commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

rustbot · 2025-11-04T18:38:07Z

⚠️ Warning ⚠️

There are issue links (such as #123) in the commit messages of the following commits.
Please move them to the PR description, to avoid spamming the issues with references to the commit, and so this bot can automatically canonicalize them to avoid issues with subtree.
- 3d3d2be

ada4a · 2025-11-04T20:57:09Z

clippy_lints/src/methods/mod.rs

                    );
                },
+                (name @ (sym::chunks_exact | sym::chunks_exact_mut), [arg]) => {
+                    chunks_exact_with_const_size::check(cx, expr, recv, arg, name, self.msrv);


Currently, the span that the lint points at is the whole method call expression (expr.span) -- as the last result in Lintcheck (https://github.com/rust-lang/rust-clippy/actions/runs/19080004877#user-content-chunks-exact-with-const-size) shows, that might lead to a somewhat confusing diagnostics:

warning: chunks_exact_with_const_size --> target/lintcheck/sources/rustc-demangle-0.1.24/src/v0.rs:299:25 | 299 | let mut bytes = self | _________________________^ 300 | | .nibbles 301 | | .as_bytes() 302 | | .chunks_exact(2) | |____________________________^ | = help: consider using `as_chunks::<2>()` for better ergonomics = note: `--force-warn clippy::chunks-exact-with-const-size` implied by `--force-warn clippy::all`

You can instead only highlight the method call (in this case, chunks_exact(2), by using call_span, which comes from the call to method_call(expr) above (line 13) -- see filter_map_bool_then for a (somewhat) simple example

I hope I understood that correctly. Done in dc9fa9d

Pretty much! Though I think the .0.iter() part was actually correct, you didn't need to remove it

In fact, it would be great if you could add a test case for a multiline call -- to make sure that we're giving the correct diagnostic

In fact, it would be great if you could add a test case for a multiline call -- to make sure that we're giving the correct diagnostic

I wanted to add a multiline test, but check-fmt.rs comes in the way. And to be honest, I do not know how to handle that issue.

You could either:

Artificially elongate the expression, e.g. by adding more intermediate method calls, so that rustfmt splits it up into multiple lines

Put the #[rustfmt::skip] attribute onto the whole statement, to avoid formatting it entirely -- but I wouldn't use that unless absolutely necessary, e.g. when you want to add tests for really bad formatting, like
vec . chunks_exact( 4)

ada4a

Great progress! Here's another couple comments^^

View changes since this review

ada4a · 2025-11-07T19:11:43Z

clippy_lints/src/methods/mod.rs

+                (name @ (sym::chunks_exact | sym::chunks_exact_mut), [arg]) => {
+                    chunks_exact_with_const_size::check(cx, recv, arg, expr.span, call_span, name, self.msrv);
+                },


Oh, I just noticed that this is located in the branch for lints that handle receivers and arguments coming from expansion. I think it would be safer to not do that, at least in the beginning -- working with from-expansion stuff can be quite error-prone -- could you please move this code to the branch under method_call (starting somewhere around line 5050)?

Done in 3cfa99a

ada4a · 2025-11-07T19:13:37Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+    // Check for Rust version
+    if !msrv.meets(cx, msrvs::AS_CHUNKS) {
+        return;
+    }


Sorry, I meant after the constant check, but before the lint emission -- currently, the check doesn't actually do anything 😅

ada4a · 2025-11-07T19:15:29Z

clippy_lints/src/methods/mod.rs

                    );
                },
+                (name @ (sym::chunks_exact | sym::chunks_exact_mut), [arg]) => {
+                    chunks_exact_with_const_size::check(cx, expr, recv, arg, name, self.msrv);


Pretty much! Though I think the .0.iter() part was actually correct, you didn't need to remove it

ada4a · 2025-11-07T19:16:35Z

clippy_lints/src/methods/mod.rs

                    );
                },
+                (name @ (sym::chunks_exact | sym::chunks_exact_mut), [arg]) => {
+                    chunks_exact_with_const_size::check(cx, expr, recv, arg, name, self.msrv);


In fact, it would be great if you could add a test case for a multiline call -- to make sure that we're giving the correct diagnostic

ada4a · 2025-11-07T19:17:17Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+            "as_chunks"
+        };
+
+        span_lint_and_help(


Awesome, thank you!

ada4a · 2025-11-07T19:21:40Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+                diag.span_suggestion(
+                    expr_span,
+                    "consider using `as_chunks` instead",
+                    suggestion,
+                    applicability,
+                );


The suggestion doesn't need to point at the whole expression either -- you can suggest replacing just the span of chunks_exact(N) (so call_span) with as_chunks::<4>().0.iter() (notice the lack of the starting ., as call_span doesn't include it). This has an additional advantage of not requiring you to get a snippet for the receiver, as you won't need that in the suggestion anymore

Done in 370d0ae

…nts may not come from expansions to reduce risk for errors

…tion to reduce costs

ada4a · 2025-11-08T10:01:20Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+        // Suggestion replaces just "chunks_exact(N)" with "as_chunks::<N>().0.iter()"
+        let suggestion = format!("{suggestion_method}::<{arg_str}>().0.iter()");
+
+        span_lint_and_sugg(
+            cx,
+            CHUNKS_EXACT_WITH_CONST_SIZE,
+            call_span,
+            format!("using `{method_name}` with a constant chunk size"),
+            "consider using `as_chunks` instead",
+            suggestion,
+            applicability,
+        );
+    }


As Lintcheck shows in #16002 (comment), here's one bigger remaining¹ problem: chunks_exact(_mut) (I'll use the immutable version from here on, for brevity) returns ChunksExact, and apart from being an iterator, that struct also has a remainder method, which returns, well, the remainder. But since we replace the whole chunks_exact call with as_chunks().0.iter(), we lose access to that remainder.

In theory, we could make the lint a lot smarter, so that when it sees that the chunk_exact is stored into a variable, and is then used both as an iterator and to get the remainder, we adjust both calls correctly. So this example from Lintcheck:

let chunk_iter = bytes.chunks_exact(CHUNK_SIZE); let remainder_chunk = chunk_iter.remainder(); for chunk in chunk_iter { /* ... */ }

would be turned into something like this:

let chunk_iter = bytes.as_chunks::<CHUNK_SIZE>(); let remainder_chunk = chunk_iter.1; for chunk in chunk_iter.0.iter() { /* ... */ }

But that'd be pretty complicated, so I suggest we do the following instead:

If we see that the call to .chunks_exact is stored into a variable,

don't offer a suggestion (as it might not be correct)

but instead give a help message, something like:
let chunk_iter = bytes.chunks_exact(CHUNK_SIZE); ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.as_chunks::<CHUNK_SIZE>() instead`

(1) can be done as follows:

if let Node::LetStmt(_) = cx.tcx.parent_hir_node(expr.hir_id) { /* only leave a help message, not a suggestion */ }

Here's how that would probably look in your code:

Suggestion

Suggested change

// Suggestion replaces just "chunks_exact(N)" with "as_chunks::<N>().0.iter()"

let suggestion = format!("{suggestion_method}::<{arg_str}>().0.iter()");

span_lint_and_sugg(

cx,

CHUNKS_EXACT_WITH_CONST_SIZE,

call_span,

format!("using `{method_name}` with a constant chunk size"),

"consider using `as_chunks` instead",

suggestion,

applicability,

);

}

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| {

if let Node::LetStmt(_) = cx.tcx.parent_hir_node(expr.hir_id) {

// The `ChunksExact(Mut)` struct is stored for later -- this likely means that the user intends to not only use it as an iterator,

// but also access the remainder using `(into_)remainder`. For now, just give a help message in this case.

// TODO: give a suggestion that replaces this:

// ```

// let chunk_iter = bytes.chunks_exact(CHUNK_SIZE);

// let remainder_chunk = chunk_iter.remainder();

// for chunk in chunk_iter {

// /* ... */

// }

// ```

// with this:

// ```

// let chunk_iter = bytes.as_chunks::<CHUNK_SIZE>();

// let remainder_chunk = chunk_iter.1;

// for chunk in chunk_iter.0.iter() {

// /* ... */

// }

// ```

diag.span_help(

call_span,

format!("consider using `{as_chunks}` instead"),

);

} else {

diag.span_suggestion(

call_span,

"consider using `as_chunks` instead",

// Suggestion replaces just "chunks_exact(N)" with "as_chunks::<N>().0.iter()"

format!("{as_chunks}.0.iter()"),

applicability,

);

}

}

);

}

Footnotes

foreshadowing :P ↩

I might get that totally wrong but isn't that in opposition to your comment above? Because I think it is useful to have the suggestion the possibility to access to the tuple.

The reason I wouldn't want to suggest that in here is that, again, I think that if the user stores the ChunksExact in a variable, then they probably want to access the remainder -- and suggesting .0.iter() would go against that. If they do want to use the variable just as an iterator, they can of course add .0.iter() themselves, but that scenario would be rather rare I think.

In general, the return type of as_chunks is pretty self-explanatory imo -- it's a tuple, and a quick glance at the API docs tells you what each half stands for, so I imagine the user will be able to figure that out...

But if we do want to be extra helpful, we could emit an additional note: given the example code from above, it could look like this:

note: you can access the chunks using `chunk_iter.0.iter()`, and the remainder using `chunk_iter.1`

To do that, you'll need to:

extract the pat from LetStmt

pat is an arbitrary pattern, since the left-hand side of a let-statement could in theory be an arbitrary pattern (e.g. destructuring), but we can assume it's just PatKind::Binding. Therefore, match on that and extract ident -- the identifier (=name) of the variable

construct the note message, and emit it using diag.span_note (after emitting the help message)

Well done!:)

Oh, but there's a caveat I forgot about and you no doubt noticed – since in one of the test cases we now only give a help message and not a suggestion, ui_test (the UI test library we're using) will fail, as even after applying all the suggestions, the test file still raises warnings, precisely because help-only cases haven't actually changed.

Because of this, such test cases are placed into a separate file, usually called <lint_name>_unfixable.rs (there's also this //@no-rustfix thing you'll often see in such files, but you don't need to worry about that for now)

I was wondering why the tests were failing. Luckily, I do not get frustrated that easily might have taken me a couple of attempts before I would have noticed.

Done in 64aae82

Btw, could you please add the comment from the suggestion (of some version of it, as you please) to your code? Having a TODO will let an interested contributor pick it up in the future

I am going to use your comment as it is more helpful and provides transparency next possible steps.

If method is stored in let binding, emit a help message instead of the fix

ada4a · 2025-11-08T13:49:42Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+            format!("using `{method_name}` with a constant chunk size"),
+            |diag| {
+                if let Node::LetStmt(let_stmt) = cx.tcx.parent_hir_node(expr.hir_id) {
+                    diag.help(format!("consider using `{as_chunks}` instead"));


You can use span_help with call_span here

Done in 83e0039

ada4a · 2025-11-08T13:50:59Z

clippy_lints/src/methods/chunks_exact_with_const_size.rs

+        let mut applicability = Applicability::MachineApplicable;
+        let arg_str = snippet_with_applicability(cx, arg.span, "_", &mut applicability);
+
+        let as_chunks = format!("{suggestion_method}::<{arg_str}>()");


nit: you should be able to use format_args! here to avoid an intermediary allocation

Done in 83e0039

…d fail

rustbot assigned Jarcho Nov 1, 2025

rustbot added needs-fcp S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Nov 1, 2025

This comment has been minimized.

Sign in to view

ada4a reviewed Nov 4, 2025

View reviewed changes

rommeld added 4 commits November 4, 2025 18:51

Add lint to suggest as_chunks over chunks_exact with constant

3d3d2be

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 rust-lang#15882

Fix pass value instead of reference

4a4c955

Switched to symbols instead of using strings

d332ec5

Added suggestions and changes from review

610acda

Changed example suggestion from const to snippet Shortend error message Followed clippy naming conventions

rommeld force-pushed the suggest-as-chunks-over-chunks-exact branch from 849dbe8 to 610acda Compare November 4, 2025 18:38

Updated CHANGELOG.md via

632e37b

ada4a reviewed Nov 4, 2025

View reviewed changes

rommeld added 5 commits November 4, 2025 22:05

Reduced error message verbosity

bc1d010

Added check for types that can be adjusted as slices

1d99b91

Moved Rust version check and removed

2731771

Added lint suggestion

7082eef

Reduced highlighting to method call for better understanding

dc9fa9d

ada4a reviewed Nov 7, 2025

View reviewed changes

rommeld added 5 commits November 8, 2025 00:15

Moved method to lints which handle methods whose receivers and argume…

afaf92b

…nts may not come from expansions to reduce risk for errors

Changed suggestion to return iterator instead of tuple

dfd8065

Moved version check after cheaper checks is slice and constant evalua…

3cfa99a

…tion to reduce costs

Changed suggestion to just consider method call

94181ab

Changed linting suggestion span_lint_and_then to span_lint_and_sugg

370d0ae

ada4a reviewed Nov 8, 2025

View reviewed changes

rommeld added 2 commits November 8, 2025 13:17

Added skipping multi-line test from cargo dev fmt

24798af

Improved lint by only suggesting fix when method not stored in variable

5e05b1d

If method is stored in let binding, emit a help message instead of the fix

rommeld added 2 commits November 8, 2025 14:35

Fixed missing curly brakets

ae2cb12

Deleted comment from lint declaration

43a7a72

ada4a reviewed Nov 8, 2025

View reviewed changes

rommeld added 4 commits November 8, 2025 14:56

Moved unfixable tests to separate file because ui_test otherwise woul…

64aae82

…d fail

Swapped plain with so help function is visually attached to method

83e0039

Fixed wrongly replaced comment in lint declaration

1e276d7

Fixed one last typo in the lint declaration comment

c50ccf8

	//~^ ERROR: using `chunks_exact` with a constant chunk size
	//~^ chunks_exact_to_as_chunks

Add lint to suggest as_chunks over chunks_exact with constant #16002

Are you sure you want to change the base?

Add lint to suggest as_chunks over chunks_exact with constant #16002

Conversation

rommeld commented Nov 1, 2025 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Nov 1, 2025

Uh oh!

This comment has been minimized.

github-actions bot commented Nov 1, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

ada4a left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rustbot commented Nov 4, 2025

Uh oh!

rustbot commented Nov 4, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ada4a left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

rommeld commented Nov 1, 2025 •

edited by rustbot

Loading

github-actions bot commented Nov 1, 2025 •

edited

Loading

ada4a left a comment •

edited by rustbot

Loading

ada4a left a comment •

edited by rustbot

Loading

ada4a Nov 8, 2025 •

edited

Loading