Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::implicit_clone: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
What it meansChecks for the usage of _.to_owned(), vec.to_vec(), or similar when calling _.clone() would be clearer. It is in the pedantic group and off by default.
What you see
warning: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type --> main.rs:4:9 | 4 | let b = a.to_vec(); | ^^^^^^^^^^ help: consider using: `a.clone()` | = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#implicit_clone = note: `-W clippy::implicit-clone` 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?
These methods do the same thing as _.clone() but may be confusing as to why we are calling to_vec on something that is already a Vec or calling to_owned on something that is already owned.
Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.
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
let a = vec![1, 2, 3];
let b = a.to_vec();
let c = a.to_owned();
Write this instead
let a = vec![1, 2, 3];
let b = a.clone();
let c = a.clone();
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]
implicit_clone = "warn"In code
#![warn(clippy::implicit_clone)]One run
cargo clippy -- -W clippy::implicit-cloneThe [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 the usage of _.to_owned(), vec.to_vec(), or similar when calling _.clone() would be clearer.
Why is this bad?
These methods do the same thing as _.clone() but may be confusing as
to why we are calling to_vec on something that is already a Vec or calling to_owned on something that is already owned.
Example
let a = vec![1, 2, 3];
let b = a.to_vec();
let c = a.to_owned();
Use instead:
let a = vec![1, 2, 3];
let b = a.clone();
let c = a.clone();
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
- if_not_elseChecks for usage of ! or != in an if condition with an else branch
- ignore_without_reasonChecks for ignored tests without messages
- ignored_unit_patternsmatching over `()` is more explicit
- implicit_hasherChecks for public impl or fn missing generalization over different hashers and implicitly defaulting to the default hashing algorithm (SipHash)
- inconsistent_struct_constructorstruct constructor field order is inconsistent with struct definition field order
- index_refutable_slicethis binding can be a slice pattern to avoid indexing
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?