Clippy lints / Performance
Clippy lint · Performance · checked with Clippy 0.1.99
clippy::useless_vec: useless use of `vec!`
What it meansChecks for usage of vec![..] when using [..] would be possible. It is in the performance group and warns by default.
What you see
warning: useless use of `vec!` --> main.rs:5:5 | 5 | foo(&vec![1, 2]); | ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]` | = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#useless_vec = note: `#[warn(clippy::useless_vec)]` on by default
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?
This is less efficient.
Code that could be written to run faster. Warns by default.
How to fix it
Clippy can fix this one for you: run cargo clippy --fix (add --allow-dirty if you have uncommitted changes). Review the diff before you commit.
Flagged
fn foo(_x: &[u8]) {}
foo(&vec![1, 2]);
Write this instead
foo(&[1, 2]);
Turn it off, or on
Allow it where it does not fit your code, as narrowly as you can:
On one item
#[allow(clippy::useless_vec)]
fn my_function() { /* ... */ }Whole crate (Cargo.toml)
[lints.clippy]
useless_vec = "allow"One run
cargo clippy -- -A clippy::useless-vecThe [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.
Settings in clippy.toml
allow-useless-vec-in-tests: Whether useless_vec should ignore test functions or #[cfg(test)]too-large-for-stack: The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
Clippy's own documentation
What it does
Checks for usage of vec![..] when using [..] would
be possible.
Why is this bad?
This is less efficient.
Example
fn foo(_x: &[u8]) {}
foo(&vec![1, 2]);
Use instead:
foo(&[1, 2]);
Configuration
-
allow-useless-vec-in-tests: Whetheruseless_vecshould ignore test functions or#[cfg(test)](default:
false) -
too-large-for-stack: The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap(default:
200)
From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.
Related lints
- large_enum_variantlarge size difference between variants
- unbuffered_bytescalling .bytes() is very inefficient when data is not in memory
- unnecessary_to_ownedunnecessary use of `to_string`
- useless_borrows_in_formattingredundant reference in `println!` argument
- vec_init_then_pushcalls to `push` immediately after creation
- waker_clone_wakeChecks for usage of waker.clone().wake()
All 847 Clippy lints · Rust compiler errors · Cargo.toml checker
Up next
Related lintclippy::large_enum_variantlarge size difference between variantsRead it next →Did this answer your question?