Maintainers
Pricing
Enterprise
More
More
Documentation
Try Live
Rankings
Install
Blog
Docs7
Ask
New
Add Docs
Rust Clippy
https://rust-lang.github.io/rust-clippy/master/index.html
Admin
Rust Clippy is a collection of lints to catch common mistakes and improve Rust code.
Tokens:
289,688
Snippets:
2,426
Trust Score:
9.7
Update:
1 week ago
Context
Chat
Benchmark
81.32
Latest
Show doc for...
Code
Info
Show Results
Tokens:
Raw
Copy
Link
Tokens:
Raw
Copy
Link
### indexing_slicing: Good example with get methods Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative using `get` methods which return `Option` and do not panic, allowing explicit handling of out-of-bounds cases. ```rust x.get(2); x.get(100); x.get(2..100); let i = 10; let j = 20; y.get(i..j); ``` -------------------------------- ### Configuration example for allowed-wildcard-imports Source: https://rust-lang.github.io/rust-clippy/master/index.html Example configuration for the 'allowed-wildcard-imports' option, listing path segments allowed to have wildcard imports. ```toml allowed-wildcard-imports = [ "utils", "common" ] ``` -------------------------------- ### non_zero_suggestions: Example of converting NonZero to regular integer Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic conversion from NonZeroU32 to u64 using get() before division and modulo operations. This is flagged by the lint. ```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()); } ``` -------------------------------- ### arithmetic-side-effects-allowed-binary configuration example Source: https://rust-lang.github.io/rust-clippy/master/index.html Configuration example for the arithmetic-side-effects-allowed-binary option, showing asymmetric pairs and wildcard support. ```toml arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]] ``` -------------------------------- ### needless_late_init: Late initialization examples Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows three examples of late initialization that can be replaced by a let statement with an initializer. ```rust let a; a = 1; let b; match 3 { 0 => b = "zero", 1 => b = "one", _ => b = "many", } let c; if true { c = 1; } else { c = -1; } ``` -------------------------------- ### create_dir: Example of std::fs::create_dir Source: https://rust-lang.github.io/rust-clippy/master/index.html Example showing the discouraged usage of std::fs::create_dir, which can fail when multiple directories need to be created or when the directory already exists. ```rust std::fs::create_dir("foo"); ``` -------------------------------- ### arithmetic-side-effects-allowed configuration example Source: https://rust-lang.github.io/rust-clippy/master/index.html Configuration example for the arithmetic-side-effects-allowed option, listing type names to suppress checking. ```toml arithmetic-side-effects-allowed = ["SomeType", "AnotherType"] ``` -------------------------------- ### arithmetic-side-effects-allowed-unary configuration example Source: https://rust-lang.github.io/rust-clippy/master/index.html Configuration example for the arithmetic-side-effects-allowed-unary option, listing type names for unary operations. ```toml arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"] ``` -------------------------------- ### expect_used: Configuration example for allow-unwrap-types Source: https://rust-lang.github.io/rust-clippy/master/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" ] ``` -------------------------------- ### std_instead_of_core: Example using std::hash::Hasher Source: https://rust-lang.github.io/rust-clippy/master/index.html Example showing the problematic import of Hasher from std. This lint is restricted to crates that want no_std compatibility. ```rust use std::hash::Hasher; ``` -------------------------------- ### absolute_paths: Example of absolute path usage Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows an example of using an absolute path like `std::f64::consts::PI`, which the lint flags. This is the problematic code that should be replaced with a `use` statement or shorter paths. ```rust let x = std::f64::consts::PI; ``` -------------------------------- ### cast_lossless: Example using `u64::from` Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement for the previous example, using `u64::from(x)` instead of `x as u64`. This conversion function is lossless and makes the intent clear. ```rust fn as_u64(x: u8) -> u64 { u64::from(x) } ``` -------------------------------- ### duration_suboptimal_units: Good example using larger time units Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement using larger units: from_secs, from_mins, and from_hours. This is the corrected version of the previous example. ```rust use std::time::Duration; let dur = Duration::from_secs(50); let dur = Duration::from_mins(30); let dur = Duration::from_hours(10); ``` -------------------------------- ### format_in_format_args: Bad example with nested format! Source: https://rust-lang.github.io/rust-clippy/master/index.html Example that triggers the lint: uses format! inside println! arguments, causing an unnecessary temporary allocation. ```rust println!("error: {}", format!("something failed at {}", Location::caller())); ``` -------------------------------- ### pathbuf_init_then_push: Good alternatives using from and join Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternatives to the bad pattern: using PathBuf::from or chaining join on a new PathBuf. ```rust let path_buf = PathBuf::from("foo"); // or let path_buf = PathBuf::new().join("foo"); ``` -------------------------------- ### needless_collect: Example of unnecessary collect Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows collecting an iterator into a Vec just to get its length, which is unnecessary. ```rust let len = iterator.collect::<Vec<_>>().len(); ``` -------------------------------- ### needless_nonzero_get: Bad example with division operator Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic pattern where `get()` is used in a division operation. ```rust let _ = 4 / nz.get(); ``` -------------------------------- ### format_push_string: Good example using write! Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement using write! with an ignored Result, avoiding the extra allocation. Requires importing std::fmt::Write as _. ```rust use std::fmt::Write as _; // import without risk of name clashing let mut s = String::new(); let _ = write!(s, "0x{:X}", 1024); ``` -------------------------------- ### needless_nonzero_get: Bad example with leading_zeros Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic pattern where `get()` is called on a NonZero value before calling a method that NonZero provides directly. ```rust let _ = nz.get().leading_zeros(); ``` -------------------------------- ### empty_docs: Good example without empty doc comment Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended code without the empty documentation comment. ```rust fn returns_true() -> bool { true } ``` -------------------------------- ### coerce_container_to_any: Good example using dereference Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the correct approach by dereferencing the Box to get a reference to the inner dyn Any, allowing downcast to succeed. ```rust let x: Box<dyn Any> = Box::new(0u32); let dyn_any_of_u32: &dyn Any = &*x; // Succeeds since we have a &dyn Any to the inner u32! assert_eq!(dyn_any_of_u32.downcast_ref::<u32>(), Some(&0u32)); ``` -------------------------------- ### chunks_exact_to_as_chunks: Good example using as_chunks Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative using as_chunks::<2>() which returns arrays for better ergonomics and type safety. ```rust let slice = [1, 2, 3, 4, 5, 6]; let (chunks, remainder) = slice.as_chunks::<2>(); for chunk in chunks {} ``` -------------------------------- ### explicit_deref_methods: Example of explicit deref() call Source: https://rust-lang.github.io/rust-clippy/master/index.html Code that triggers explicit_deref_methods: using a.deref() to get a &str from a &mut String. The lint suggests using &*a instead. ```rust use std::ops::Deref; let a: &mut String = &mut String::from("foo"); let b: &str = a.deref(); ``` -------------------------------- ### Using Waker::noop() (good example) Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement using Waker::noop() to create a no-op waker. ```rust use std::task::Waker; let waker = Waker::noop(); ``` -------------------------------- ### duration_subsec: Bad example calculating subsecond units manually Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows manual division of subsec_nanos() to get microseconds and milliseconds, which the lint flags as less concise. ```rust let micros = duration.subsec_nanos() / 1_000; let millis = duration.subsec_nanos() / 1_000_000; ``` -------------------------------- ### join_absolute_paths: Example of Path::join with leading separator Source: https://rust-lang.github.io/rust-clippy/master/index.html Demonstrates the problematic case where joining a path starting with a separator overwrites the original path, resulting in "/sh". ```rust let path = Path::new("/bin"); let joined_path = path.join("/sh"); assert_eq!(joined_path, PathBuf::from("/sh")); ``` -------------------------------- ### pathbuf_init_then_push: Bad example with push after new Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic pattern: creating a PathBuf and then calling push. The lint suggests using PathBuf::from or join instead. ```rust let mut path_buf = PathBuf::new(); path_buf.push("foo"); ``` -------------------------------- ### for_unbounded_range: Example of unbounded range Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows an unbounded range starting at 250u8, which can cause panics or infinite loops due to overflow. The lint suggests setting a max value. ```rust for i in 250u8.. { println!("{i}"); } ``` -------------------------------- ### seek_from_current: Example of seek(SeekFrom::Current(0)) Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic use of seek(SeekFrom::Current(0)) to get the current stream position, which the lint suggests replacing with stream_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(()) } ``` -------------------------------- ### option_env_unwrap: Good example with env!() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the compile-time safe alternative using env!. Use this to replace option_env!().unwrap(). ```rust let _ = env!("HOME"); ``` -------------------------------- ### doc_nested_refdefs: Example of link reference definition in list item Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows a link reference definition at the start of a list item, which triggers the lint. The definition is likely intended as an intra-doc link. ```rust //! - [link]: description ``` -------------------------------- ### chars_next_cmp: Problematic usage of chars().next() Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of code that triggers the chars_next_cmp lint: using chars().next() to check if a string starts with a given char. This is flagged as style warn and is machine applicable. ```rust let name = "foo"; if name.chars().next() == Some('_') {}; ``` -------------------------------- ### create_dir: Use std::fs::create_dir_all instead Source: https://rust-lang.github.io/rust-clippy/master/index.html Recommended replacement using std::fs::create_dir_all to avoid failures when creating multiple directories or when the directory already exists. ```rust std::fs::create_dir_all("foo"); ``` -------------------------------- ### reversed_empty_ranges: Example of problematic reversed range Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows a range expression (10..=0) that is empty because the start is greater than the end, and a slice index (3..1) that will panic at runtime. This triggers the reversed_empty_ranges lint. ```rust fn main() { (10..=0).for_each(|x| println!("{}", x)); let arr = [1, 2, 3, 4, 5]; let sub = &arr[3..1]; } ``` -------------------------------- ### module_name_repetitions: Configuration example for allowed-prefixes Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows how to configure the allowed-prefixes option for this lint, using a TOML array. ```toml allowed-prefixes = [ "to", "from" ] ``` -------------------------------- ### bytes_nth: Good example using .as_bytes().get() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement for `.bytes().nth()`: `.as_bytes().get()` is more efficient and readable. ```rust "Hello".as_bytes().get(3); ``` -------------------------------- ### inefficient_to_string: Example of inefficient and efficient to_string() calls Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic pattern of calling to_string() on &&str (slow) and the correct pattern using &s to get &str (fast). The comment indicates the generic implementation for T: Display is used in the slow case. ```rust // Generic implementation for `T: Display` is used (slow) ["foo", "bar"].iter().map(|s| s.to_string()); // OK, the specialized impl is used ["foo", "bar"].iter().map(|&s| s.to_string()); ``` -------------------------------- ### Ordered trait example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a trait with items in the correct alphabetical order, used as the recommended alternative to the unordered example. ```rust trait TraitOrdered { const A: bool; const B: bool; const C: bool; type SomeType; fn a(); fn b(); fn c(); } ``` -------------------------------- ### Configure module item order groupings Source: https://rust-lang.github.io/rust-clippy/master/index.html Example configuration for `module-item-order-groupings` that places modules and use statements at the top, with all other items in an 'everything_else' group. ```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", ], ], ] ``` -------------------------------- ### renamed_function_params: Configuration example for allow-renamed-params-for Source: https://rust-lang.github.io/rust-clippy/master/index.html Example configuration showing how to ignore a specific trait path for the lint. ```toml allow-renamed-params-for = [ "std::convert::From" ] ``` -------------------------------- ### ip_constant: Good example using predefined IP constants Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement for ip_constant: use Ipv4Addr::LOCALHOST and Ipv6Addr::LOCALHOST instead of explicit addresses. ```rust use std::net::{Ipv4Addr, Ipv6Addr}; // IPv4 loopback let addr_v4 = Ipv4Addr::LOCALHOST; // IPv6 loopback let addr_v6 = Ipv6Addr::LOCALHOST; ``` -------------------------------- ### Allowed alternative type example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a similar type that is allowed by the configuration, shown as a replacement suggestion. ```rust // A similar type that is allowed by the config use std::collections::HashMap; ``` -------------------------------- ### trivial_regex: Good example Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows using str::starts_with instead of a trivial regex. ```rust str::starts_with("foobar") ``` -------------------------------- ### manual_ilog2: Example of manual ilog2 implementation Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the problematic patterns: using leading_zeros or ilog(2) to compute the base-2 logarithm. ```rust let x: u32 = 5; let log = 31 - x.leading_zeros(); let log = x.ilog(2); ``` -------------------------------- ### rc_clone_in_vec_init: Recommended alternatives Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows two recommended alternatives for the rc_clone_in_vec_init lint: initializing each value separately with a loop, or creating the reference beforehand and cloning it explicitly. ```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]; ``` -------------------------------- ### char_indices_as_byte_indices: Good example using char_indices() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative using char_indices() which yields byte indices and avoids panics. ```rust for (idx, c) in s.char_indices() { let _ = s[idx..]; } ``` -------------------------------- ### suboptimal_flops: Improved floating-point expressions using built-in methods Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement for the previous example, using methods like exp2, exp, sqrt, log2, log10, ln, powi, mul_add, and abs. ```rust use std::f32::consts::E; let a = 3f32; let _ = a.exp2(); let _ = a.exp(); let _ = a.sqrt(); let _ = a.log2(); let _ = a.log10(); let _ = a.ln(); let _ = a.powi(2); let _ = a.mul_add(2.0, 4.0); let _ = a.abs(); let _ = -a.abs(); ``` -------------------------------- ### upper_case_acronyms: Example of fully capitalized name Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a struct name with fully capitalized acronym, which the lint warns about. ```rust struct HTTPResponse; ``` -------------------------------- ### unwrap_used: Example of unwrap calls Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of code that uses unwrap() on Option and Result, which the lint warns about because it can panic. ```rust option.unwrap(); result.unwrap(); ``` -------------------------------- ### assigning_clones: Good example using clone_from() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the corrected code that uses 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); } ``` -------------------------------- ### unwrap_in_result: Before example with expect() Source: https://rust-lang.github.io/rust-clippy/master/index.html Before example for the unwrap_in_result lint: a function returning Result uses expect(), which can panic on error. ```rust fn divisible_by_3(i_str: String) -> Result<(), String> { let i = i_str .parse::<i32>() .expect("cannot divide the input by three"); if i % 3 != 0 { Err("Number is not divisible by 3")? } Ok(()) } ``` -------------------------------- ### Idiomatic alternative using utility methods Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement: using `is_ok()`, `is_err()`, `is_none()`, `is_some()`, `is_pending()`, `is_ready()`, `is_ipv4()`, `is_ipv6()`, or direct condition checks. This is more concise and clear. ```rust if Ok::<i32, i32>(42).is_ok() {} if Err::<i32, i32>(42).is_err() {} if None::<()>.is_none() {} if Some(42).is_some() {} if Poll::Pending::<()>.is_pending() {} if Poll::Ready(42).is_ready() {} if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {} if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {} Ok::<i32, i32>(42).is_ok(); let cond = true; if cond {} cond; ``` -------------------------------- ### large_digit_groups: example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a constant with digit groups that are too large, triggering the lint. The grouping negatively impacts readability. ```rust let x: u64 = 6186491_8973511; ``` -------------------------------- ### search_is_some: Use instead example with any/contains Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended concise alternatives using any() and contains() instead of search followed by is_some() or is_none(). ```rust let vec = vec![1]; vec.iter().any(|x| *x == 0); !"hello world".contains("world"); ``` -------------------------------- ### Unordered trait example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a trait with items in an unordered arrangement, used to illustrate the lint's detection. ```rust trait TraitUnordered { const A: bool; const C: bool; const B: bool; type SomeType; fn a(); fn c(); fn b(); } ``` -------------------------------- ### suspicious_op_assign_impl lint example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of the suspicious_op_assign_impl lint. The code subtracts in an `AddAssign` impl, which is likely a typo or copy-and-paste error. ```rust impl AddAssign for Foo { fn add_assign(&mut self, other: Foo) { *self = *self - other; } } ``` -------------------------------- ### duration_subsec: Good example using dedicated methods Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended direct calls to subsec_micros() and subsec_millis() instead of manual calculations. ```rust let micros = duration.subsec_micros(); let millis = duration.subsec_millis(); ``` -------------------------------- ### manual_repeat_n: repeat().take() example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of using repeat().take() which can be replaced with repeat_n(). This pattern is flagged by the manual_repeat_n lint. ```rust let _ = std::iter::repeat(10).take(3); ``` -------------------------------- ### into_iter_on_ref: Good example using iter instead Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement for the into_iter_on_ref lint. Use iter or iter_mut directly on the reference. ```rust (&vec).iter(); ``` -------------------------------- ### crosspointer_transmute: Example of transmute between type and pointer Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of a transmute between a type T and a pointer to that type, which is easy to mistake and is flagged by this lint. ```rust core::intrinsics::transmute(t) // where the result type is the same as // `*t` or `&t`'s ``` -------------------------------- ### unwrap_in_result: After example with map_err() Source: https://rust-lang.github.io/rust-clippy/master/index.html After example for the unwrap_in_result lint: the function uses map_err() to convert the parse error into a String, avoiding a panic. ```rust fn divisible_by_3(i_str: String) -> Result<(), String> { let i = i_str .parse::<i32>() .map_err(|e| format!("cannot divide the input by three: {}", e))?; if i % 3 != 0 { Err("Number is not divisible by 3")? } Ok(()) } ``` -------------------------------- ### similar_names: Example 2 with similar names Source: https://rust-lang.github.io/rust-clippy/master/index.html Another example of similar names that differ by one character, triggering the similar_names lint. ```rust let orange = val; let ornange = val2; ``` -------------------------------- ### self_named_constructors: Good example with constructor named new Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative: naming the constructor `new` instead of `foo` to avoid repeating the type name. ```rust struct Foo {} impl Foo { pub fn new() -> Foo { Foo {} } } ``` -------------------------------- ### inherent_to_string: Example of inherent to_string method Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows an example that triggers the 'inherent_to_string' lint: defining an inherent 'to_string' method on a struct. ```rust pub struct A; impl A { pub fn to_string(&self) -> String { "I am A".to_string() } } ``` -------------------------------- ### unwrap_or_default: Example of unwrap_or with default Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of code that uses unwrap_or and or_insert_with with default values, which the lint suggests replacing with unwrap_or_default and or_default. ```rust x.unwrap_or(Default::default()); map.entry(42).or_insert_with(String::new); ``` -------------------------------- ### vec_init_then_push: Example of Vec::new() followed by push calls Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the inefficient pattern of creating a Vec with Vec::new() and then pushing elements individually. ```rust let mut v = Vec::new(); v.push(0); v.push(1); v.push(2); ``` -------------------------------- ### manual_retain: filter().collect() example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of using filter().collect() to filter a vector, which can be replaced with retain(). This pattern is flagged by the manual_retain lint. ```rust let mut vec = vec![0, 1, 2]; vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect(); vec = vec.into_iter().filter(|x| x % 2 == 0).collect(); ``` -------------------------------- ### infinite_loop: Corrected example with break condition Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows an alternative correction for the infinite loop example by adding a 'break' condition to exit the loop. ```rust fn run_forever() { loop { // do something if condition { break; } } } ``` -------------------------------- ### cmp_null: Good example using `.is_null()` Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended replacement using the inherent `.is_null()` method for readability. ```rust if x.is_null() { // .. } ``` -------------------------------- ### Disallowed type usage example Source: https://rust-lang.github.io/rust-clippy/master/index.html Example of using a disallowed type (`BTreeMap`) that would trigger the lint. Shows both an import and a direct usage. ```rust use std::collections::BTreeMap; // or its use let x = std::collections::BTreeMap::new(); ``` -------------------------------- ### manual_strip: Bad example using starts_with and slicing Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the non-idiomatic pattern that triggers the manual_strip lint. It uses starts_with and then slices the string using the pattern's length, which can panic and is less readable. ```rust let s = "hello, world!"; if s.starts_with("hello, ") { assert_eq!(s["hello, ".len()..].to_uppercase(), "WORLD!"); } ``` -------------------------------- ### disallowed_fields: Example clippy.toml configuration Source: https://rust-lang.github.io/rust-clippy/master/index.html Example configuration for the disallowed-fields lint, showing how to specify fields as strings or inline tables with 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" }, ] ``` -------------------------------- ### manual_find_map: Bad example Source: https://rust-lang.github.io/rust-clippy/master/index.html Using find followed by map, which can be simplified to find_map. ```rust (0_i32..10) .find(|n| n.checked_add(1).is_some()) .map(|n| n.checked_add(1).unwrap()); ``` -------------------------------- ### option_as_ref_cloned: Good example with clone() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the concise fix by cloning the Option directly. Use this to replace the as_ref().cloned() pattern. ```rust fn foo(bar: &Option<Vec<u8>>) -> Option<Vec<u8>> { bar.clone() } ``` -------------------------------- ### dbg_macro: Example of dbg! macro usage Source: https://rust-lang.github.io/rust-clippy/master/index.html Example showing the discouraged usage of the dbg! macro, which is intended for debugging and should not be present in released software. ```rust dbg!(true) ``` -------------------------------- ### Example of missing_inline_in_public_items lint Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows a Rust code example that triggers the `missing_inline_in_public_items` lint. The example includes public functions without `#[inline]`, trait methods with default implementations, and public methods in a public struct that are missing `#[inline]`. Items that are private or already marked `#[inline]` are considered okay. ```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] } ``` -------------------------------- ### bool_assert_comparison: Good example using assert! Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative: using assert! with the negated boolean expression. ```rust assert!(!"a".is_empty()); ``` -------------------------------- ### try_from_instead_of_from_str: Example of TryFrom<&str> implementation Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows a typical `TryFrom<&str>` implementation that could be replaced with `FromStr`. The `try_from` method is empty in this example. ```rust impl TryFrom<&str> for MyType { type Error = MyError; fn try_from(value: &str) -> Result<Self, Self::Error> { } } ``` -------------------------------- ### clear_with_drain: Good example using clear() Source: https://rust-lang.github.io/rust-clippy/master/index.html Shows the recommended alternative using .clear() which is more efficient and clearer in intent. ```rust let mut v = vec![1, 2, 3]; v.clear(); ```
