Rust Clippy

https://rust-lang.github.io/rust-clippy/stable/
Admin
Rust Clippy is a collection of lints (static analysis checks) for the Rust programming language,...
Tokens:287,438
Snippets:2,389
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### unwrap_used: Configuration example for allow-unwrap-types

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows an example configuration for the allow-unwrap-types option, allowing unwrap on LockResult.

```toml
allow-unwrap-types = [ "std::sync::LockResult" ]
```

--------------------------------

### manual_hash_one: Example of manual hashing with build_hasher

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the manual hashing pattern that triggers the manual_hash_one lint: building a hasher, hashing a value, and finishing to get the hash. This is more verbose than using `hash_one`.

```rust
use std::hash::{BuildHasher, Hash, Hasher};
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let value = vec![1, 2, 3];

let mut hasher = s.build_hasher();
value.hash(&mut hasher);
let hash = hasher.finish();

```

--------------------------------

### manual_ilog2: good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using ilog2() directly.

```rust
let x: u32 = 5;
let log = x.ilog2();
let log = x.ilog2();

```

--------------------------------

### manual_is_finite: Good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using the is_finite method.

```rust
if x.is_finite() {}
if x.is_finite() {}

```

--------------------------------

### expect_used: Configuration example for allow-unwrap-types

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example configuration for the allow-unwrap-types option, which lists types that are allowed to use unwrap() and expect() on. The default is an empty list.

```toml
allow-unwrap-types = [ "std::sync::LockResult" ]

```

--------------------------------

### manual_is_infinite: Good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using the is_infinite method.

```rust
if x.is_infinite() {}

```

--------------------------------

### module_name_repetitions: Configuration example for allowed-prefixes

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows how to configure the allowed-prefixes option for this lint.

```toml
allowed-prefixes = [ "to", "from" ]

```

--------------------------------

### manual_is_power_of_two: Good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using the is_power_of_two method.

```rust
let a: u32 = 4;
let result = a.is_power_of_two();

```

--------------------------------

### min_ident_chars: Corrected example with descriptive names

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternative to the previous example, using descriptive variable names like 'movie' and 'title' to improve readability.

```rust
for movie in movies {
    let title = movie.title;
}

```

--------------------------------

### string_lit_as_bytes: Good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended byte string literal replacement.

```rust
let bstr = b"a byte string";
```

--------------------------------

### manual_is_multiple_of: Good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using the is_multiple_of method.

```rust
if a.is_multiple_of(b) {
    println!("{a} is divisible by {b}");
}

```

--------------------------------

### Example clippy.toml configuration for disallowed-types

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Configuration example showing how to list disallowed types in clippy.toml. Supports string paths, inline tables with `path`, `reason`, `replacement`, and `allow-invalid` fields.

```toml
disallowed-types = [
    # Can use a string as the path of the disallowed type.
    "std::collections::BTreeMap",
    # Can also use an inline table with a `path` key.
    { path = "std::net::TcpListener" },
    # When using an inline table, can add a `reason` for why the type
    # is disallowed.
    { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
    # Can also add a `replacement` that will be offered as a suggestion.
    { path = "std::sync::Mutex", reason = "prefer faster & simpler non-poisonable mutex", replacement = "parking_lot::Mutex" },
    # This would normally error if the path is incorrect, but with `allow-invalid` = `true`,
    # it will be silently ignored
    { path = "std::invalid::Type", reason = "use alternative instead", allow-invalid = true }
]

```

--------------------------------

### size_of_ref: Correct use of size_of_val with self

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Corrected version of the size_of_ref example, using size_of_val(self) to get the size of the value behind the reference.

```rust
struct Foo {
    buffer: [u8],
}

impl Foo {
    fn size(&self) -> usize {
        // Correct
        size_of_val(self)
    }
}

```

--------------------------------

### main_recursion: Example of recursion in main()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the pattern that triggers the main_recursion lint: calling main() recursively from within main(). This is considered an anti-pattern except in special setups.

```rust
fn main() {
    main();
}

```

--------------------------------

### manual_inspect: good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using inspect, which is clearer in intent and shorter.

```rust
let x = Some(0).inspect(|x| println!("{x}"));

```

--------------------------------

### format_push_string: Good example using write!

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using write! to avoid the extra allocation. Requires importing std::fmt::Write and ignoring the Result with let _ =.

```rust
use std::fmt::Write as _; // import without risk of name clashing

let mut s = String::new();
let _ = write!(s, "0x{:X}", 1024);

```

--------------------------------

### seek_from_current: Example using seek(SeekFrom::Current(0))

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the code that triggers the `seek_from_current` lint: using `seek(SeekFrom::Current(0))` to get the current position.

```rust
use std::fs::File;
use std::io::{self, Write, Seek, SeekFrom};

fn main() -> io::Result<()> {
    let mut f = File::create("foo.txt")?;
    f.write_all(b"Hello")?;
    eprintln!("Written {} bytes", f.seek(SeekFrom::Current(0))?);

    Ok(())
}
```

--------------------------------

### needless_collect: Bad example using collect::<Vec<_>>().len()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the problematic pattern: collecting an iterator into a Vec just to get its length. The lint suggests using count() instead.

```rust
let len = iterator.collect::<Vec<_>>().len();

```

--------------------------------

### pathbuf_init_then_push: Good alternatives using PathBuf::from and join

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternatives: using PathBuf::from or chaining new().join(). Note that join introduces an implicit clone, while PathBuf::from avoids it.

```rust
let path_buf = PathBuf::from("foo");
// or
let path_buf = PathBuf::new().join("foo");
```

--------------------------------

### wildcard_dependencies: Good example with specific version

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement: using specific version requirements like `~1.2.3` or `=1.2.3` instead of wildcards.

```toml
[dependencies]
some_crate_1 = "~1.2.3"

some_crate_2 = "=1.2.3"
```

--------------------------------

### chars_next_cmp: Bad example - using chars().next()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the problematic pattern of checking if a string starts with a character using chars().next(). The lint suggests using starts_with instead.

```rust
let name = "foo";
if name.chars().next() == Some('_') {};
```

--------------------------------

### non_zero_suggestions: Example of unnecessary NonZero to integer conversion

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the pattern that triggers the non_zero_suggestions lint: converting NonZeroU32 to u64 via get() before division and modulo operations. This loses type-safety and efficiency.

```rust
use std::num::{NonZeroU32, NonZeroU64};

fn example(x: u64, y: NonZeroU32) {
    // Bad: Converting NonZeroU32 to u64 unnecessarily
    let r1 = x / u64::from(y.get());
    let r2 = x % u64::from(y.get());
}

```

--------------------------------

### mut_mutex_lock: Example using `Mutex::lock`

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows code that triggers the `mut_mutex_lock` lint: using `Arc::get_mut` to get a mutable reference to the `Mutex` and then calling `lock().unwrap()` to mutate the value.

```rust
use std::sync::{Arc, Mutex};

let mut value_rc = Arc::new(Mutex::new(42_u8));
let value_mutex = Arc::get_mut(&mut value_rc).unwrap();

let mut value = value_mutex.lock().unwrap();
*value += 1;

```

--------------------------------

### Large Include File Example (Fixed with Runtime Loading)

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternative: loading the file at runtime using `std::fs`, avoiding the binary size increase.

```rust
use std::fs;

// You can load the file at runtime
let string = fs::read_to_string("very_large_file.txt")?;
let bytes = fs::read("very_large_file.txt")?;

```

--------------------------------

### vec_init_then_push: Corrected example using vec! macro

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement for `vec_init_then_push`: using the `vec!` macro.

```rust
let v = vec![0, 1, 2];

```

--------------------------------

### doc_nested_refdefs: Example of link reference definition in list item

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a doc comment with a link reference definition at the start of a list item, which triggers the lint. The comment uses a bullet list with a reference definition.

```rust
//! - [link]: description

```

--------------------------------

### manual_assert: Good example using assert!

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the idiomatic alternative to if-then-panic!: using the assert! macro, which is simpler and more concise.

```rust
let sad_people: Vec<&str> = vec![];
assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);

```

--------------------------------

### seek_to_start_instead_of_rewind: problematic code using seek(SeekFrom::Start(0))

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the lint: using seek with SeekFrom::Start(0) to jump to the start of a stream. The lint suggests using rewind() instead for readability.

```rust
fn foo<T: io::Seek>(t: &mut T) {
    t.seek(io::SeekFrom::Start(0));
}

```

--------------------------------

### assigning_clones: Good example with clone_from()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended pattern using `clone_from` to avoid unnecessary allocations.

```rust
struct Thing;

impl Clone for Thing {
    fn clone(&self) -> Self { todo!() }
    fn clone_from(&mut self, other: &Self) { todo!() }
}

pub fn assign_to_ref(a: &mut Thing, b: Thing) {
    a.clone_from(&b);
}

```

--------------------------------

### float_arithmetic: Example of float arithmetic

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

A simple example of floating-point arithmetic that the lint flags.

```rust
a + 1.0;

```

--------------------------------

### borrow_deref_ref: Bad example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the lint: borrowing a dereferenced reference.

```rust
let s = &String::new();

let a: &String = &* s;

```

--------------------------------

### create_dir: Example of std::fs::create_dir

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the problematic usage of std::fs::create_dir that the lint flags. Using create_dir can fail when creating multiple directories or if the directory already exists.

```rust
std::fs::create_dir("foo");
```

--------------------------------

### duplicated_attributes: Corrected example with single attribute

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the corrected version of the duplicated_attributes example, with the attribute appearing only once.

```rust
#[allow(dead_code)]
fn foo() {}

```

--------------------------------

### get_first: Correct example using x.first()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement for the get_first lint: using x.first() on a Vec or slice.

```rust
let x = vec![2, 3, 5];
let first_element = x.first();

```

--------------------------------

### wildcard_imports: Configuration example for allowed-wildcard-imports

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows how to configure the `allowed-wildcard-imports` option to allow wildcard imports for specific path segments.

```toml
allowed-wildcard-imports = [ "utils", "common" ]
```

--------------------------------

### borrow_interior_mutable_const: Bad example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the lint: storing to a constant atomic does not change its value.

```rust
use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
const CONST_ATOM: AtomicUsize = AtomicUsize::new(12);

CONST_ATOM.store(6, SeqCst); // the content of the atomic is unchanged
assert_eq!(CONST_ATOM.load(SeqCst), 12); // because the CONST_ATOM in these lines are distinct

```

--------------------------------

### only_used_in_recursion: Example not caught by lint

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example that the lint does not catch: the argument b is only used in recursion but through a closure, which is a known limitation.

```rust
fn foo(a: usize, b: usize) -> usize {
    let f = |x| x + 1;

    if a == 0 {
        1
    } else {
        foo(a - 1, f(b))
    }
}
```

--------------------------------

### some_filter: Good example using then_some()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using then_some() which is more concise and readable.

```rust
let x = false;
x.then_some(0);

```

--------------------------------

### Configure module item order groupings

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example configuration for `module-item-order-groupings` that places modules and use statements at the top, with all other items grouped together.

```toml
module-item-order-groupings = [
    [ "modules", [ "extern_crate", "mod", "foreign_mod" ], ],
    [ "use", [ "use", ], ],
    [ "everything_else", [ "macro", "global_asm", "static", "const", "ty_alias", "enum", "struct", "union", "trait", "trait_alias", "impl", "fn", ], ],
]

```

--------------------------------

### large_digit_groups: example of large digit groups

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of a numeric constant with digit groups that are too large, which negatively impacts readability.

```rust
let x: u64 = 6186491_8973511;

```

--------------------------------

### disallowed_fields: Example clippy.toml configuration

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example configuration for the disallowed-fields lint, showing how to specify fields with path and optional reason.

```toml
disallowed-fields = [
    # Can use a string as the path of the disallowed field.
    "std::ops::Range::start",
    # Can also use an inline table with a `path` key.
    { path = "std::ops::Range::start" },
    # When using an inline table, can add a `reason` for why the field
    # is disallowed.
    { path = "std::ops::Range::start", reason = "The start of the range is not used" },
]

```

--------------------------------

### alloc_instead_of_core: Correct import from core

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Recommended replacement for the previous example: import from `core` instead of `alloc` to ensure no_std compatibility.

```rust
use core::slice::from_ref;

```

--------------------------------

### Unordered trait example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of a trait with unordered associated items, demonstrating the lint's detection of non-alphabetical ordering.

```rust
trait TraitUnordered {
    const A: bool;
    const C: bool;
    const B: bool;

    type SomeType;

    fn a();
    fn c();
    fn b();
}

```

--------------------------------

### std_instead_of_alloc: Good example using alloc::vec::Vec

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended import from alloc to ensure no_std compatibility.

```rust
use alloc::vec::Vec;

```

--------------------------------

### pathbuf_init_then_push: Bad example with PathBuf::new() and push

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the pattern that triggers the lint: creating a new PathBuf and immediately calling push. The lint suggests using join or PathBuf::from instead.

```rust
let mut path_buf = PathBuf::new();
path_buf.push("foo");
```

--------------------------------

### Example of missing_inline_in_public_items lint

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a Rust code example that triggers the lint for public items missing `#[inline]`, while private items and items with `#[inline]` are allowed. The example includes a public function, a trait with a default method, and implementations for public and private structs.

```rust
pub fn foo() {} // missing #[inline]
fn ok() {} // ok
#[inline] pub fn bar() {} // ok
#[inline(always)] pub fn baz() {} // ok

pub trait Bar {
  fn bar(); // ok
  fn def_bar() {} // missing #[inline]
}

struct Baz;
impl Baz {
    fn private() {} // ok
}

impl Bar for Baz {
  fn bar() {} // ok - Baz is not exported
}

pub struct PubBaz;
impl PubBaz {
    fn private() {} // ok
    pub fn not_private() {} // missing #[inline]
}

impl Bar for PubBaz {
    fn bar() {} // missing #[inline]
    fn def_bar() {} // missing #[inline]
}

```

--------------------------------

### suspicious_operation_groupings: Corrected comparison example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Corrected version of the previous example, comparing self.x to other.x instead of other.y, avoiding the lint.

```rust
// same as above except:
impl PartialEq for Vec3 {
    fn eq(&self, other: &Self) -> bool {
        // Note we now compare other.x to self.x
        self.x == other.x && self.y == other.y && self.z == other.z
    }
}

```

--------------------------------

### same_item_push: using vec! and resize (good example)

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternative to the for loop: using vec![item1; 20] and vec.resize(20 + 30, item2) to achieve the same result more succinctly and with better performance.

```rust
let item1 = 2;
let item2 = 3;
let mut vec: Vec<u8> = vec![item1; 20];
vec.resize(20 + 30, item2);

```

--------------------------------

### similar_names: Example 2 of similar names

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Another example of similar names that differ by a single character, also triggering the similar_names lint.

```rust
let orange = val;
let ornange = val2;

```

--------------------------------

### semicolon_if_nothing_returned: Example without semicolon

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the semicolon_if_nothing_returned lint. The last expression in the main function returns () but is not followed by a semicolon.

```rust
fn main() {
    println!("Hello world")
}
```

--------------------------------

### manual_ignore_case_cmp: good example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using eq_ignore_ascii_case, which is faster and more readable.

```rust
fn compare(a: &str, b: &str) -> bool {
    a.eq_ignore_ascii_case(b) || a.eq_ignore_ascii_case("abc")
}

```

--------------------------------

### suspicious_command_arg_space: Correct example using args

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternative using args() to pass multiple arguments separately.

```rust
std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
```

--------------------------------

### mistyped_literal_suffixes: Example of mistyped suffixes

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows examples of mistyped literal suffixes: `2_32` should be `2_i32` and `250_8` should be `250_u8`. The lint warns on such typos.

```rust
`2_32` => `2_i32`
`250_8 => `250_u8`

```

--------------------------------

### transmuting_null: Example of transmuting a null pointer

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a transmute that creates a reference from a null pointer, which is undefined behavior. This is the problematic example for the transmuting_null lint.

```rust
let null_ref: &u64 = unsafe { std::mem::transmute(0 as *const u64) };

```

--------------------------------

### with_capacity_zero: Good example using new()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement: using `new()` instead of `with_capacity(0)`, which is more idiomatic and a `const fn`.

```rust
let v: Vec<i32> = Vec::new();
let s = String::new();
```

--------------------------------

### fn_to_numeric_cast_with_truncation: Bad cast example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of a function pointer cast to a numeric type that is not wide enough to store an address, which discards bits of the address.

```rust
fn fn1() -> i16 {
    1
};
let _ = fn1 as i32;

```

--------------------------------

### chars_next_cmp: Better version - using starts_with

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement using starts_with, which is more concise and readable.

```rust
let name = "foo";
if name.starts_with('_') {};
```

--------------------------------

### transmutes_expressible_as_ptr_casts: Example of unnecessary transmute

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a transmute from *const [i32] to *const [u16] that could be expressed as a pointer cast. This is the problematic example for the transmutes_expressible_as_ptr_casts lint.

```rust
unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };

```

--------------------------------

### Example: Implementing Hash, Borrow<str>, and Borrow<[u8]> for a type

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a type `ExampleType` that implements `Hash`, `Borrow<str>`, and `Borrow<[u8]>`. This triggers the lint because hashing the type and hashing the borrowed values produce different results, violating the `Borrow` and `Hash` equivalence requirements.

```rust
use std::borrow::Borrow;
use std::hash::{Hash, Hasher};

struct ExampleType {
    data: String
}

impl Hash for ExampleType {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.data.hash(state);
    }
}

impl Borrow<str> for ExampleType {
    fn borrow(&self) -> &str {
        &self.data
    }
}

impl Borrow<[u8]> for ExampleType {
    fn borrow(&self) -> &[u8] {
        self.data.as_bytes()
    }
}
```

--------------------------------

### semicolon_inside_block: Example with semicolon outside block

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the semicolon_inside_block lint. The semicolon is placed outside the block, and the lint suggests moving it inside.

```rust
unsafe { f(x) };
```

--------------------------------

### unbuffered_bytes: Good example using BufReader

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended fix: wrap the File in a BufReader to implement BufRead and improve efficiency.

```rust
use std::io::{BufReader, Read};
use std::fs::File;
let file = BufReader::new(File::open("./bytes.txt").unwrap());
file.bytes();

```

--------------------------------

### repeat_once: Corrected example using .clone()

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the corrected version of the previous example, using .clone() instead of .repeat(1), which is the suggested replacement for String.

```rust
fn main() {
    let x = String::from("hello world").clone();
}

```

--------------------------------

### mutex_atomic: Mutex::new(&y) example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the mutex_atomic lint: using a Mutex to wrap a reference. The lint suggests using AtomicBool instead.

```rust
let x = Mutex::new(&y);

```

--------------------------------

### mixed_attributes_style: Example of mixed attribute styles

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows an example that triggers the lint: using both outer `#[cfg(linux)]` and inner `#![cfg(windows)]` attributes on the same item.

```rust
#[cfg(linux)]
pub fn foo() {
    #![cfg(windows)]
}

```

--------------------------------

### reserve_after_initialization: Recommended code using Vec::with_capacity

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended alternative for the reserve_after_initialization lint: using Vec::with_capacity to create a vector with known capacity directly.

```rust
let mut v: Vec<usize> = Vec::with_capacity(10);

```

--------------------------------

### eq_op: Example of equal operands in comparison and assertion

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows two examples of equal operands: a comparison in an if statement and an assertion with equal arguments, both triggering the lint.

```rust
if x + 1 == x + 1 {}

// or

assert_eq!(a, a);
```

--------------------------------

### wildcard_imports: Good example with explicit import

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement: importing the specific item by name instead of using a wildcard.

```rust
use crate1::foo;

foo();
```

--------------------------------

### duplicate_underscore_argument: Corrected example with distinct argument names

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the corrected version of the duplicate_underscore_argument example, using `_b` instead of `_a` to avoid the similar names.

```rust
fn bar(a: i32, _b: i32) {}

```

--------------------------------

### rc_clone_in_vec_init: Better alternatives

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows two recommended alternatives for the rc_clone_in_vec_init lint: initializing each value separately, or creating the reference beforehand to clarify cloning.

```rust
// Initialize each value separately:
let mut data = Vec::with_capacity(100);
for _ in 0..100 {
    data.push(std::rc::Rc::new("some data".to_string()));
}

// Or if you want clones of the same reference,
// Create the reference beforehand to clarify that
// it should be cloned for each value
let data = std::rc::Rc::new("some data".to_string());
let v = vec![data; 100];

```

--------------------------------

### init_numbered_fields: Example of tuple struct with field syntax

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a tuple struct initialized with field syntax, which the lint flags. Also shows the recommended tuple initializer and a case with a base initializer that is allowed.

```rust
struct TupleStruct(u8, u16);

let _ = TupleStruct {
    0: 1,
    1: 23,
};

// should be written as
let base = TupleStruct(1, 23);

// This is OK however
let _ = TupleStruct { 0: 42, ..base };

```

--------------------------------

### block_scrutinee: Example of wrapped scrutinee

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows an example that triggers the lint: a match/if let scrutinee wrapped in a block. This lint only triggers on the 2021 edition and older.

```rust
if let Some(x) = { my_function() } { .. }
```

--------------------------------

### transmute_undefined_repr: Example of undefined transmute

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows a transmute between Foo<u32> and Foo<i32> without a defined representation, which is undefined behavior. This is the problematic example for the transmute_undefined_repr lint.

```rust
struct Foo<T>(u32, T);
let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };

```

--------------------------------

### manual_swap: Manual swap example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the manual swapping pattern that the lint detects. The lint is not emitted in const blocks because the suggestion would not be applicable.

```rust
let mut a = 42;
let mut b = 1337;

let t = b;
b = a;
a = t;

```

--------------------------------

### temporary_assignment: Example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of constructing a tuple and immediately assigning to its element, which triggers the temporary_assignment lint. The lint suggests writing the desired structure directly for better readability.

```rust
(0, 0).0 = 1

```

--------------------------------

### wildcard_in_or_patterns: Good example with only wildcard

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the recommended replacement: using only the wildcard pattern, which already covers any other pattern.

```rust
match s {
    "a" => {},
    _ => {},
}
```

--------------------------------

### create_dir: Use create_dir_all instead

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Suggests using std::fs::create_dir_all instead of create_dir to avoid failures when creating multiple directories or when the directory already exists.

```rust
std::fs::create_dir_all("foo");
```

--------------------------------

### tabs_in_doc_comments: Example with tabs

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of a doc comment containing tab characters, which triggers the tabs_in_doc_comments lint. The lint suggests replacing tabs with spaces for consistent indentation.

```rust
///
/// Struct to hold two strings:
/// 	- first		one
/// 	- second	one
pub struct DoubleString {
   ///
   /// 	- First String:
   /// 		- needs to be inside here
   first_string: String,
   ///
   /// 	- Second String:
   /// 		- needs to be inside here
   second_string: String,
}

```

--------------------------------

### mutex_integer: Mutex::new(0usize) example

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Example of code that triggers the mutex_integer lint: using a Mutex to wrap an integer. The lint suggests using AtomicUsize instead.

```rust
let x = Mutex::new(0usize);

```

--------------------------------

### std_instead_of_core: Example of using std::hash::Hasher

Source: https://rust-lang.github.io/rust-clippy/stable/index.html

Shows the problematic import of Hasher from std, which should be replaced with core for no_std compatibility.

```rust
use std::hash::Hasher;

```
Tokens:
Raw