Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::needless_pass_by_value: this argument is passed by value, but not consumed in the function body
What it meansChecks for functions taking arguments by value, but not consuming them in its body. It is in the pedantic group and off by default.
What you see
warning: this argument is passed by value, but not consumed in the function body --> main.rs:3:11 | 3 | fn foo(v: Vec<i32>) { | ^^^^^^^^ help: consider changing the type to: `&[i32]` | = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#needless_pass_by_value = note: `-W clippy::needless-pass-by-value` implied by `-W clippy::pedantic`
Real output of Clippy 0.1.99 (Rust 1.99) on the example below. Names and line numbers in yours will differ.
Does it matter?
Taking arguments by reference is more flexible and can sometimes avoid unnecessary allocations.
Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.
How to fix it
Clippy does not fix this one automatically (its suggestion may change behaviour, so it only shows it). Change the code by hand:
Flagged
fn foo(v: Vec<i32>) {
assert_eq!(v.len(), 42);
}
Write this instead
fn foo(v: &[i32]) {
assert_eq!(v.len(), 42);
}
Turn it off, or on
It is off by default. To use it, set it to warn or deny:
Whole crate (Cargo.toml)
[lints.clippy]
needless_pass_by_value = "warn"In code
#![warn(clippy::needless_pass_by_value)]One run
cargo clippy -- -W clippy::needless-pass-by-valueThe [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.
Clippy's own documentation
What it does
Checks for functions taking arguments by value, but not consuming them in its body.
Why is this bad?
Taking arguments by reference is more flexible and can sometimes avoid unnecessary allocations.
Known problems
- This lint suggests taking an argument by reference,
however sometimes it is better to let users decide the argument type
(by using
Borrowtrait, for example), depending on how the function is used.
Example
fn foo(v: Vec<i32>) {
assert_eq!(v.len(), 42);
}
should be
fn foo(v: &[i32]) {
assert_eq!(v.len(), 42);
}
From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.
Related lints
- too_many_linesChecks for functions with a large amount of lines
- missing_errors_docChecks the doc comments of publicly visible functions that return a Result type and warns if there is no # Errors section
- must_use_candidateChecks for public functions that have no #[must_use] attribute, but return something not already marked must-use, have no mutable arg and mutate no statics
- needless_bitwise_booluse of bitwise operator instead of lazy operator between booleans
- needless_continueThe lint checks for if-statements appearing in loops that contain a continue statement in either their main blocks or their else-blocks, when omitting the else-block possibly with some rearrangement of code can make the code easier to understand. The lint also checks if the last statement in the loop is a continue
- needless_for_eachneedless use of `for_each`
- needless_raw_string_hashesunnecessary hashes around raw string literal
- no_effect_underscore_bindingbinding to `_` prefixed variable with no side-effect
- no_mangle_with_rust_abi`#[no_mangle]` set on a function with the default (`Rust`) ABI
All 847 Clippy lints · Rust compiler errors · Cargo.toml checker
Up next
Related lintclippy::too_many_linesChecks for functions with a large amount of linesRead it next →Did this answer your question?