nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-28 02:57:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #11699 - Alexendoo:no-run-doctests, r=llogiq

Browse Source 
Set doc-tests to `no_run`

This excludes `should_panic` tests, those are still run to ensure they panic. Most of our other doc snippets don't gain much from being run though so this frees up a nice bit of CI time

It also fixes the occasional issue such as `foo.txt`s being created f942470ca7/clippy_lints/src/permissions_set_readonly_false.rs (L19)

changelog: none
This commit is contained in:
bors 2023-10-23 18:15:01 +00:00
commit 033c763943
233 changed files with 991 additions and 991 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
book/src/lint_configuration.md
View File

@ -774,7 +774,7 @@ Additional dotfiles (files or directories starting with a dot) to allow
## `enforce-iter-loop-reborrow`
#### Example
```
```no_run
let mut vec = vec![1, 2, 3];
let rmvec = &mut vec;
for _ in rmvec.iter() {}
@ -782,7 +782,7 @@ for _ in rmvec.iter_mut() {}
```
Use instead:
```
```no_run
let mut vec = vec![1, 2, 3];
let rmvec = &mut vec;
for _ in &*rmvec {}

4
clippy_dev/src/new_lint.rs
View File

@ -346,11 +346,11 @@ fn get_lint_declaration(name_upper: &str, category: &str) -> String {
/// ### Why is this bad?
///
/// ### Example
/// ```rust
/// ```no_run
/// // example code where clippy issues a warning
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// // example code which does not raise clippy warning
/// ```
#[clippy::version = "{}"]

4
clippy_lints/src/absolute_paths.rs
View File

@ -24,11 +24,11 @@ declare_clippy_lint! {
/// using absolute paths is the proper way of referencing items in one.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x = std::f64::consts::PI;
/// ```
/// Use any of the below instead, or anything else:
/// ```rust
/// ```no_run
/// use std::f64;
/// use std::f64::consts;
/// use std::f64::consts::PI;

4
clippy_lints/src/almost_complete_range.rs
View File

@ -17,11 +17,11 @@ declare_clippy_lint! {
/// This (`'a'..'z'`) is almost certainly a typo meant to include all letters.
///
/// ### Example
/// ```rust
/// ```no_run
/// let _ = 'a'..'z';
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let _ = 'a'..='z';
/// ```
#[clippy::version = "1.68.0"]

4
clippy_lints/src/approx_const.rs
View File

@ -24,12 +24,12 @@ declare_clippy_lint! {
/// issue](https://github.com/rust-lang/rust/issues).
///
/// ### Example
/// ```rust
/// ```no_run
/// let x = 3.14;
/// let y = 1_f64 / x;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let x = std::f32::consts::PI;
/// let y = std::f64::consts::FRAC_1_PI;
/// ```

2
clippy_lints/src/arc_with_non_send_sync.rs
View File

@ -18,7 +18,7 @@ declare_clippy_lint! {
/// either `T` should be made `Send + Sync` or an `Rc` should be used instead of an `Arc`
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::cell::RefCell;
/// # use std::sync::Arc;
///

4
clippy_lints/src/async_yields_async.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// An await is likely missing.
///
/// ### Example
/// ```rust
/// ```no_run
/// async fn foo() {}
///
/// fn bar() {
@ -26,7 +26,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// async fn foo() {}
///
/// fn bar() {

42
clippy_lints/src/attrs.rs
View File

@ -129,7 +129,7 @@ declare_clippy_lint! {
/// a valid semver. Failing that, the contained information is useless.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[deprecated(since = "forever")]
/// fn something_else() { /* ... */ }
/// ```
@ -156,14 +156,14 @@ declare_clippy_lint! {
/// currently works for basic cases but is not perfect.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[allow(dead_code)]
///
/// fn not_quite_good_code() { }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// // Good (as inner attribute)
/// #![allow(dead_code)]
///
@ -198,25 +198,25 @@ declare_clippy_lint! {
/// Does not detect empty lines after doc attributes (e.g. `#[doc = ""]`).
///
/// ### Example
/// ```rust
/// ```no_run
/// /// Some doc comment with a blank line after it.
///
/// fn not_quite_good_code() { }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// /// Good (no blank line)
/// fn this_is_fine() { }
/// ```
///
/// ```rust
/// ```no_run
/// // Good (convert to a regular comment)
///
/// fn this_is_fine_too() { }
/// ```
///
/// ```rust
/// ```no_run
/// //! Good (convert to a comment on an inner attribute)
///
/// fn this_is_fine_as_well() { }
@ -236,12 +236,12 @@ declare_clippy_lint! {
/// These lints should only be enabled on a lint-by-lint basis and with careful consideration.
///
/// ### Example
/// ```rust
/// ```no_run
/// #![deny(clippy::restriction)]
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #![deny(clippy::as_conversions)]
/// ```
#[clippy::version = "1.47.0"]
@ -265,13 +265,13 @@ declare_clippy_lint! {
/// [#3123](https://github.com/rust-lang/rust-clippy/pull/3123#issuecomment-422321765)
///
/// ### Example
/// ```rust
/// ```no_run
/// #[cfg_attr(rustfmt, rustfmt_skip)]
/// fn main() { }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #[rustfmt::skip]
/// fn main() { }
/// ```
@ -290,13 +290,13 @@ declare_clippy_lint! {
/// by the conditional compilation engine.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[cfg(linux)]
/// fn conditional() { }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # mod hidden {
/// #[cfg(target_os = "linux")]
/// fn conditional() { }
@ -325,14 +325,14 @@ declare_clippy_lint! {
/// ensure that others understand the reasoning
///
/// ### Example
/// ```rust
/// ```no_run
/// #![feature(lint_reasons)]
///
/// #![allow(clippy::some_lint)]
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #![feature(lint_reasons)]
///
/// #![allow(clippy::some_lint, reason = "False positive rust-lang/rust-clippy#1002020")]
@ -352,7 +352,7 @@ declare_clippy_lint! {
/// panicking with the expected message, and not another unrelated panic.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn random() -> i32 { 0 }
///
/// #[should_panic]
@ -363,7 +363,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn random() -> i32 { 0 }
///
/// #[should_panic = "attempt to divide by zero"]
@ -386,13 +386,13 @@ declare_clippy_lint! {
/// If there is only one condition, no need to wrap it into `any` or `all` combinators.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[cfg(any(unix))]
/// pub struct Bar;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #[cfg(unix)]
/// pub struct Bar;
/// ```
@ -412,13 +412,13 @@ declare_clippy_lint! {
/// may cause conditional compilation not work quitely.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[cfg(features = "some-feature")]
/// fn conditional() { }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #[cfg(feature = "some-feature")]
/// fn conditional() { }
/// ```

10
clippy_lints/src/await_holding_invalid.rs
View File

@ -29,7 +29,7 @@ declare_clippy_lint! {
/// to wrap the `.lock()` call in a block instead of explicitly dropping the guard.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::sync::Mutex;
/// # async fn baz() {}
/// async fn foo(x: &Mutex<u32>) {
@ -47,7 +47,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::sync::Mutex;
/// # async fn baz() {}
/// async fn foo(x: &Mutex<u32>) {
@ -87,7 +87,7 @@ declare_clippy_lint! {
/// to wrap the `.borrow[_mut]()` call in a block instead of explicitly dropping the ref.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::cell::RefCell;
/// # async fn baz() {}
/// async fn foo(x: &RefCell<u32>) {
@ -105,7 +105,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::cell::RefCell;
/// # async fn baz() {}
/// async fn foo(x: &RefCell<u32>) {
@ -151,7 +151,7 @@ declare_clippy_lint! {
/// ]
/// ```
///
/// ```rust
/// ```no_run
/// # async fn baz() {}
/// struct CustomLockType;
/// struct OtherCustomLockType;

4
clippy_lints/src/blocks_in_if_conditions.rs
View File

@ -21,7 +21,7 @@ declare_clippy_lint! {
/// Style, using blocks in the condition makes it hard to read.
///
/// ### Examples
/// ```rust
/// ```no_run
/// # fn somefunc() -> bool { true };
/// if { true } { /* ... */ }
///
@ -29,7 +29,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # fn somefunc() -> bool { true };
/// if true { /* ... */ }
///

4
clippy_lints/src/bool_assert_comparison.rs
View File

@ -18,13 +18,13 @@ declare_clippy_lint! {
/// It is shorter to use the equivalent.
///
/// ### Example
/// ```rust
/// ```no_run
/// assert_eq!("a".is_empty(), false);
/// assert_ne!("a".is_empty(), true);
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// assert!(!"a".is_empty());
/// ```
#[clippy::version = "1.53.0"]

6
clippy_lints/src/bool_to_int_with_if.rs
View File

@ -21,7 +21,7 @@ declare_clippy_lint! {
/// See https://doc.rust-lang.org/std/primitive.bool.html#impl-From%3Cbool%3E
///
/// ### Example
/// ```rust
/// ```no_run
/// # let condition = false;
/// if condition {
/// 1_i64
@ -30,12 +30,12 @@ declare_clippy_lint! {
/// };
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let condition = false;
/// i64::from(condition);
/// ```
/// or
/// ```rust
/// ```no_run
/// # let condition = false;
/// condition as i64;
/// ```

6
clippy_lints/src/borrow_deref_ref.rs
View File

@ -19,7 +19,7 @@ declare_clippy_lint! {
///
/// ### Known problems
/// False negative on such code:
/// ```
/// ```no_run
/// let x = &12;
/// let addr_x = &x as *const _ as usize;
/// let addr_y = &&*x as *const _ as usize; // assert ok now, and lint triggered.
@ -28,14 +28,14 @@ declare_clippy_lint! {
/// ```
///
/// ### Example
/// ```rust
/// ```no_run
/// let s = &String::new();
///
/// let a: &String = &* s;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let s = &String::new();
/// let a: &String = s;
/// ```

4
clippy_lints/src/box_default.rs
View File

@ -24,11 +24,11 @@ declare_clippy_lint! {
/// [in certain cases](https://nnethercote.github.io/perf-book/standard-library-types.html#box).
///
/// ### Example
/// ```rust
/// ```no_run
/// let x: Box<String> = Box::new(Default::default());
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let x: Box<String> = Box::default();
/// ```
#[clippy::version = "1.66.0"]

70
clippy_lints/src/casts/mod.rs
View File

@ -45,7 +45,7 @@ declare_clippy_lint! {
/// those places in the code.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x = u64::MAX;
/// x as f64;
/// ```
@ -67,7 +67,7 @@ declare_clippy_lint! {
/// as a one-time check to see where numerical wrapping can arise.
///
/// ### Example
/// ```rust
/// ```no_run
/// let y: i8 = -1;
/// y as u128; // will return 18446744073709551615
/// ```
@ -90,13 +90,13 @@ declare_clippy_lint! {
/// checks could be beneficial.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn as_u8(x: u64) -> u8 {
/// x as u8
/// }
/// ```
/// Use instead:
/// ```
/// ```no_run
/// fn as_u8(x: u64) -> u8 {
/// if let Ok(x) = u8::try_from(x) {
/// x
@ -132,7 +132,7 @@ declare_clippy_lint! {
/// example below.
///
/// ### Example
/// ```rust
/// ```no_run
/// u32::MAX as i32; // will yield a value of `-1`
/// ```
#[clippy::version = "pre 1.29.0"]
@ -155,7 +155,7 @@ declare_clippy_lint! {
/// people reading the code to know that the conversion is lossless.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn as_u64(x: u8) -> u64 {
/// x as u64
/// }
@ -163,7 +163,7 @@ declare_clippy_lint! {
///
/// Using `::from` would look like this:
///
/// ```rust
/// ```no_run
/// fn as_u64(x: u8) -> u64 {
/// u64::from(x)
/// }
@ -191,14 +191,14 @@ declare_clippy_lint! {
/// intermediate references, raw pointers and trait objects may or may not work.
///
/// ### Example
/// ```rust
/// ```no_run
/// let _ = 2i32 as i32;
/// let _ = 0.5 as f32;
/// ```
///
/// Better:
///
/// ```rust
/// ```no_run
/// let _ = 2_i32;
/// let _ = 0.5_f32;
/// ```
@ -223,7 +223,7 @@ declare_clippy_lint! {
/// u64-> u8 -> u16 can be fine. Miri is able to do a more in-depth analysis.
///
/// ### Example
/// ```rust
/// ```no_run
/// let _ = (&1u8 as *const u8) as *const u16;
/// let _ = (&mut 1u8 as *mut u8) as *mut u16;
///
@ -249,13 +249,13 @@ declare_clippy_lint! {
/// Casting to isize also doesn't make sense since there are no signed addresses.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn fun() -> i32 { 1 }
/// let _ = fun as i64;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # fn fun() -> i32 { 1 }
/// let _ = fun as usize;
/// ```
@ -276,7 +276,7 @@ declare_clippy_lint! {
/// a comment) to perform the truncation.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn fn1() -> i16 {
/// 1
/// };
@ -284,7 +284,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// // Cast to usize first, then comment with the reason for the truncation
/// fn fn1() -> i16 {
/// 1
@ -310,7 +310,7 @@ declare_clippy_lint! {
/// pointer casts in your code.
///
/// ### Example
/// ```rust
/// ```no_run
/// // fn1 is cast as `usize`
/// fn fn1() -> u16 {
/// 1
@ -319,7 +319,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// // maybe you intended to call the function?
/// fn fn2() -> u16 {
/// 1
@ -378,14 +378,14 @@ declare_clippy_lint! {
/// it cannot accidentally change the pointer's mutability nor cast the pointer to other types like `usize`.
///
/// ### Example
/// ```rust
/// ```no_run
/// let ptr: *const u32 = &42_u32;
/// let mut_ptr: *mut u32 = &mut 42_u32;
/// let _ = ptr as *const i32;
/// let _ = mut_ptr as *mut i32;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let ptr: *const u32 = &42_u32;
/// let mut_ptr: *mut u32 = &mut 42_u32;
/// let _ = ptr.cast::<i32>();
@ -408,13 +408,13 @@ declare_clippy_lint! {
/// type.
///
/// ### Example
/// ```rust
/// ```no_run
/// let ptr: *const u32 = &42_u32;
/// let mut_ptr = ptr as *mut u32;
/// let ptr = mut_ptr as *const u32;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let ptr: *const u32 = &42_u32;
/// let mut_ptr = ptr.cast_mut();
/// let ptr = mut_ptr.cast_const();
@ -434,7 +434,7 @@ declare_clippy_lint! {
/// The resulting integral value will not match the value of the variant it came from.
///
/// ### Example
/// ```rust
/// ```no_run
/// enum E { X = 256 };
/// let _ = E::X as u8;
/// ```
@ -457,7 +457,7 @@ declare_clippy_lint! {
///
/// ### Example
/// // Missing data
/// ```rust
/// ```no_run
/// let a = [1_i32, 2, 3, 4];
/// let p = &a as *const [i32] as *const [u8];
/// unsafe {
@ -465,7 +465,7 @@ declare_clippy_lint! {
/// }
/// ```
/// // Undefined Behavior (note: also potential alignment issues)
/// ```rust
/// ```no_run
/// let a = [1_u8, 2, 3, 4];
/// let p = &a as *const [u8] as *const [u32];
/// unsafe {
@ -473,7 +473,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Instead use `ptr::slice_from_raw_parts` to construct a slice from a data pointer and the correct length
/// ```rust
/// ```no_run
/// let a = [1_i32, 2, 3, 4];
/// let old_ptr = &a as *const [i32];
/// // The data pointer is cast to a pointer to the target `u8` not `[u8]`
@ -497,7 +497,7 @@ declare_clippy_lint! {
/// The cast is easily confused with casting a c-like enum value to an integer.
///
/// ### Example
/// ```rust
/// ```no_run
/// enum E { X(i32) };
/// let _ = E::X as usize;
/// ```
@ -515,12 +515,12 @@ declare_clippy_lint! {
/// The `unsigned_abs()` method avoids panic when called on the MIN value.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x: i32 = -42;
/// let y: u32 = x.abs() as u32;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let x: i32 = -42;
/// let y: u32 = x.unsigned_abs();
/// ```
@ -541,13 +541,13 @@ declare_clippy_lint! {
/// The lint is allowed by default as using `_` is less wordy than always specifying the type.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn foo(n: usize) {}
/// let n: u16 = 256;
/// foo(n as _);
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn foo(n: usize) {}
/// let n: u16 = 256;
/// foo(n as usize);
@ -570,7 +570,7 @@ declare_clippy_lint! {
/// Read the `ptr::addr_of` docs for more information.
///
/// ### Example
/// ```rust
/// ```no_run
/// let val = 1;
/// let p = &val as *const i32;
///
@ -578,7 +578,7 @@ declare_clippy_lint! {
/// let p_mut = &mut val_mut as *mut i32;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let val = 1;
/// let p = std::ptr::addr_of!(val);
///
@ -627,13 +627,13 @@ declare_clippy_lint! {
/// mutability is used, making it unlikely that having it as a mutable pointer is correct.
///
/// ### Example
/// ```rust
/// ```no_run
/// let mut vec = Vec::<u8>::with_capacity(1);
/// let ptr = vec.as_ptr() as *mut u8;
/// unsafe { ptr.write(4) }; // UNDEFINED BEHAVIOUR
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let mut vec = Vec::<u8>::with_capacity(1);
/// let ptr = vec.as_mut_ptr();
/// unsafe { ptr.write(4) };
@ -675,12 +675,12 @@ declare_clippy_lint! {
/// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
///
/// ### Example
/// ```rust
/// ```no_run
/// let a = 0 as *const u32;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let a = std::ptr::null::<u32>();
/// ```
#[clippy::version = "pre 1.29.0"]

4
clippy_lints/src/checked_conversions.rs
View File

@ -19,13 +19,13 @@ declare_clippy_lint! {
/// Reduces the readability of statements & is error prone.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let foo: u32 = 5;
/// foo <= i32::MAX as u32;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let foo = 1;
/// # #[allow(unused)]
/// i32::try_from(foo).is_ok();

4
clippy_lints/src/collapsible_if.rs
View File

@ -32,7 +32,7 @@ declare_clippy_lint! {
/// makes code look more complex than it really is.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let (x, y) = (true, true);
/// if x {
/// if y {
@ -42,7 +42,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let (x, y) = (true, true);
/// if x && y {
/// // …

4
clippy_lints/src/collection_is_never_read.rs
View File

@ -20,7 +20,7 @@ declare_clippy_lint! {
/// instead.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let samples = vec![3, 1, 2];
/// let mut sorted_samples = samples.clone();
/// sorted_samples.sort();
@ -29,7 +29,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let samples = vec![3, 1, 2];
/// let mut sorted_samples = samples.clone();
/// sorted_samples.sort();

4
clippy_lints/src/crate_in_macro_def.rs
View File

@ -18,7 +18,7 @@ declare_clippy_lint! {
/// https://doc.rust-lang.org/reference/macros-by-example.html#hygiene
///
/// ### Example
/// ```rust
/// ```no_run
/// #[macro_export]
/// macro_rules! print_message {
/// () => {
@ -28,7 +28,7 @@ declare_clippy_lint! {
/// pub const MESSAGE: &str = "Hello!";
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[macro_export]
/// macro_rules! print_message {
/// () => {

8
clippy_lints/src/default.rs
View File

@ -23,12 +23,12 @@ declare_clippy_lint! {
/// generic `Default`.
///
/// ### Example
/// ```rust
/// ```no_run
/// let s: String = Default::default();
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let s = String::default();
/// ```
#[clippy::version = "pre 1.29.0"]
@ -49,7 +49,7 @@ declare_clippy_lint! {
/// Assignments to patterns that are of tuple type are not linted.
///
/// ### Example
/// ```
/// ```no_run
/// # #[derive(Default)]
/// # struct A { i: i32 }
/// let mut a: A = Default::default();
@ -57,7 +57,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```
/// ```no_run
/// # #[derive(Default)]
/// # struct A { i: i32 }
/// let a = A {

4
clippy_lints/src/default_constructed_unit_structs.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// This adds code complexity and an unnecessary function call.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::marker::PhantomData;
/// #[derive(Default)]
/// struct S<T> {
@ -29,7 +29,7 @@ declare_clippy_lint! {
/// };
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::marker::PhantomData;
/// struct S<T> {
/// _marker: PhantomData<T>

4
clippy_lints/src/default_instead_of_iter_empty.rs
View File

@ -14,12 +14,12 @@ declare_clippy_lint! {
/// ### Why is this bad?
/// `std::iter::empty()` is the more idiomatic way.
/// ### Example
/// ```rust
/// ```no_run
/// let _ = std::iter::Empty::<usize>::default();
/// let iter: std::iter::Empty<usize> = std::iter::Empty::default();
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let _ = std::iter::empty::<usize>();
/// let iter: std::iter::Empty<usize> = std::iter::empty();
/// ```

4
clippy_lints/src/default_numeric_fallback.rs
View File

@ -31,13 +31,13 @@ declare_clippy_lint! {
/// This lint can only be allowed at the function level or above.
///
/// ### Example
/// ```rust
/// ```no_run
/// let i = 10;
/// let f = 1.23;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let i = 10i32;
/// let f = 1.23f64;
/// ```

4
clippy_lints/src/default_union_representation.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// specified layout. These cases may lead to undefined behavior in unsafe blocks.
///
/// ### Example
/// ```rust
/// ```no_run
/// union Foo {
/// a: i32,
/// b: u32,
@ -30,7 +30,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[repr(C)]
/// union Foo {
/// a: i32,

16
clippy_lints/src/dereference.rs
View File

@ -29,14 +29,14 @@ declare_clippy_lint! {
/// when not part of a method chain.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::ops::Deref;
/// let a: &mut String = &mut String::from("foo");
/// let b: &str = a.deref();
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let a: &mut String = &mut String::from("foo");
/// let b = &*a;
/// ```
@ -68,7 +68,7 @@ declare_clippy_lint! {
/// in such a case can change the semantics of the code.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn fun(_a: &i32) {}
///
/// let x: &i32 = &&&&&&5;
@ -76,7 +76,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # fn fun(_a: &i32) {}
/// let x: &i32 = &5;
/// fun(x);
@ -95,7 +95,7 @@ declare_clippy_lint! {
/// The address-of operator at the use site is clearer about the need for a reference.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x = Some("");
/// if let Some(ref x) = x {
/// // use `x` here
@ -103,7 +103,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let x = Some("");
/// if let Some(x) = x {
/// // use `&x` here
@ -123,12 +123,12 @@ declare_clippy_lint! {
/// This unnecessarily complicates the code.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x = String::new();
/// let y: &str = &*x;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let x = String::new();
/// let y: &str = &x;
/// ```

4
clippy_lints/src/derivable_impls.rs
View File

@ -21,7 +21,7 @@ declare_clippy_lint! {
/// It is less concise.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo {
/// bar: bool
/// }
@ -36,7 +36,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #[derive(Default)]
/// struct Foo {
/// bar: bool

4
clippy_lints/src/derive.rs
View File

@ -173,7 +173,7 @@ declare_clippy_lint! {
/// `Eq` themselves.
///
/// ### Example
/// ```rust
/// ```no_run
/// #[derive(PartialEq)]
/// struct Foo {
/// i_am_eq: i32,
@ -181,7 +181,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[derive(PartialEq, Eq)]
/// struct Foo {
/// i_am_eq: i32,

2
clippy_lints/src/disallowed_macros.rs
View File

@ -35,7 +35,7 @@ declare_clippy_lint! {
/// { path = "serde::Serialize", reason = "no serializing" },
/// ]
/// ```
/// ```
/// ```no_run
/// use serde::Serialize;
///
/// // Example code where clippy issues a warning

2
clippy_lints/src/disallowed_names.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// avoided.
///
/// ### Example
/// ```rust
/// ```no_run
/// let foo = 3.14;
/// ```
#[clippy::version = "pre 1.29.0"]

2
clippy_lints/src/disallowed_script_idents.rs
View File

@ -30,7 +30,7 @@ declare_clippy_lint! {
/// [`non_ascii_idents`]: https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html#non-ascii-idents
///
/// ### Example
/// ```rust
/// ```no_run
/// // Assuming that `clippy.toml` contains the following line:
/// // allowed-scripts = ["Latin", "Cyrillic"]
/// let counter = 10; // OK, latin is allowed.

22
clippy_lints/src/doc.rs
View File

@ -58,14 +58,14 @@ declare_clippy_lint! {
/// would fail.
///
/// ### Examples
/// ```rust
/// ```no_run
/// /// Do something with the foo_bar parameter. See also
/// /// that::other::module::foo.
/// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
/// fn doit(foo_bar: usize) {}
/// ```
///
/// ```rust
/// ```no_run
/// // Link text with `[]` brackets should be written as following:
/// /// Consume the array and return the inner
/// /// [`SmallVec<[T; INLINE_CAPACITY]>`][SmallVec].
@ -88,7 +88,7 @@ declare_clippy_lint! {
/// preconditions, so that users can be sure they are using them safely.
///
/// ### Examples
/// ```rust
/// ```no_run
///# type Universe = ();
/// /// This function should really be documented
/// pub unsafe fn start_apocalypse(u: &mut Universe) {
@ -98,7 +98,7 @@ declare_clippy_lint! {
///
/// At least write a line about safety:
///
/// ```rust
/// ```no_run
///# type Universe = ();
/// /// # Safety
/// ///
@ -126,7 +126,7 @@ declare_clippy_lint! {
/// Since the following function returns a `Result` it has an `# Errors` section in
/// its doc comment:
///
/// ```rust
/// ```no_run
///# use std::io;
/// /// # Errors
/// ///
@ -155,7 +155,7 @@ declare_clippy_lint! {
/// Since the following function may panic it has a `# Panics` section in
/// its doc comment:
///
/// ```rust
/// ```no_run
/// /// # Panics
/// ///
/// /// Will panic if y is 0
@ -182,7 +182,7 @@ declare_clippy_lint! {
/// if the `fn main()` is left implicit.
///
/// ### Examples
/// ```rust
/// ```no_run
/// /// An example of a doctest with a `main()` function
/// ///
/// /// # Examples
@ -210,12 +210,12 @@ declare_clippy_lint! {
/// It is likely a typo when defining an intra-doc link
///
/// ### Example
/// ```rust
/// ```no_run
/// /// See also: ['foo']
/// fn bar() {}
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// /// See also: [`foo`]
/// fn bar() {}
/// ```
@ -235,7 +235,7 @@ declare_clippy_lint! {
/// need to describe safety preconditions that users are required to uphold.
///
/// ### Examples
/// ```rust
/// ```no_run
///# type Universe = ();
/// /// # Safety
/// ///
@ -248,7 +248,7 @@ declare_clippy_lint! {
/// The function is safe, so there shouldn't be any preconditions
/// that have to be explained for safety reasons.
///
/// ```rust
/// ```no_run
///# type Universe = ();
/// /// This function should really be documented
/// pub fn start_apocalypse(u: &mut Universe) {

4
clippy_lints/src/double_parens.rs
View File

@ -12,7 +12,7 @@ declare_clippy_lint! {
/// mistake.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn simple_double_parens() -> i32 {
/// ((0))
/// }
@ -22,7 +22,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn simple_no_parens() -> i32 {
/// 0
/// }

6
clippy_lints/src/drop_forget_ref.rs
View File

@ -16,7 +16,7 @@ declare_clippy_lint! {
/// have been intended.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo;
/// let x = Foo;
/// std::mem::drop(x);
@ -36,7 +36,7 @@ declare_clippy_lint! {
/// have been intended.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo;
/// let x = Foo;
/// std::mem::forget(x);
@ -57,7 +57,7 @@ declare_clippy_lint! {
/// destructor, possibly causing leaks.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::mem;
/// # use std::rc::Rc;
/// mem::forget(Rc::new(55))

4
clippy_lints/src/else_if_without_else.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// Some coding guidelines require this (e.g., MISRA-C:2004 Rule 14.10).
///
/// ### Example
/// ```rust
/// ```no_run
/// # fn a() {}
/// # fn b() {}
/// # let x: i32 = 1;
@ -28,7 +28,7 @@ declare_clippy_lint! {
///
/// Use instead:
///
/// ```rust
/// ```no_run
/// # fn a() {}
/// # fn b() {}
/// # let x: i32 = 1;

4
clippy_lints/src/empty_drop.rs
View File

@ -16,7 +16,7 @@ declare_clippy_lint! {
/// destructured, which might be the intention behind adding the implementation as a marker.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct S;
///
/// impl Drop for S {
@ -24,7 +24,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct S;
/// ```
#[clippy::version = "1.62.0"]

4
clippy_lints/src/empty_enum.rs
View File

@ -23,12 +23,12 @@ declare_clippy_lint! {
///
///
/// ### Example
/// ```rust
/// ```no_run
/// enum Test {}
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// #![feature(never_type)]
///
/// struct Test(!);

4
clippy_lints/src/empty_structs_with_brackets.rs
View File

@ -15,11 +15,11 @@ declare_clippy_lint! {
/// Empty brackets after a struct declaration can be omitted.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Cookie {}
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct Cookie;
/// ```
#[clippy::version = "1.62.0"]

6
clippy_lints/src/entry.rs
View File

@ -23,7 +23,7 @@ declare_clippy_lint! {
///
/// ### Known problems
/// The suggestion may have type inference errors in some cases. e.g.
/// ```rust
/// ```no_run
/// let mut map = std::collections::HashMap::new();
/// let _ = if !map.contains_key(&0) {
/// map.insert(0, 0)
@ -33,7 +33,7 @@ declare_clippy_lint! {
/// ```
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::collections::HashMap;
/// # let mut map = HashMap::new();
/// # let k = 1;
@ -43,7 +43,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::collections::HashMap;
/// # let mut map = HashMap::new();
/// # let k = 1;

2
clippy_lints/src/enum_clike.rs
View File

@ -19,7 +19,7 @@ declare_clippy_lint! {
/// architectures, but works fine on 64 bit.
///
/// ### Example
/// ```rust
/// ```no_run
/// # #[cfg(target_pointer_width = "64")]
/// #[repr(usize)]
/// enum NonPortable {

4
clippy_lints/src/escape.rs
View File

@ -28,12 +28,12 @@ declare_clippy_lint! {
/// into something.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn foo(x: Box<u32>) {}
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn foo(x: u32) {}
/// ```
#[clippy::version = "pre 1.29.0"]

4
clippy_lints/src/excessive_bools.rs
View File

@ -22,7 +22,7 @@ declare_clippy_lint! {
/// readability and API.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct S {
/// is_pending: bool,
/// is_processing: bool,
@ -31,7 +31,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// enum S {
/// Pending,
/// Processing,

8
clippy_lints/src/exhaustive_items.rs
View File

@ -17,14 +17,14 @@ declare_clippy_lint! {
/// disable them by default.
///
/// ### Example
/// ```rust
/// ```no_run
/// enum Foo {
/// Bar,
/// Baz
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[non_exhaustive]
/// enum Foo {
/// Bar,
@ -47,14 +47,14 @@ declare_clippy_lint! {
/// disable them by default.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo {
/// bar: u8,
/// baz: String,
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[non_exhaustive]
/// struct Foo {
/// bar: u8,

2
clippy_lints/src/exit.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// the main function.
///
/// ### Example
/// ```
/// ```no_run
/// std::process::exit(0)
/// ```
///

4
clippy_lints/src/explicit_write.rs
View File

@ -19,7 +19,7 @@ declare_clippy_lint! {
/// Using `(e)println! is clearer and more concise
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::io::Write;
/// # let bar = "furchtbar";
/// writeln!(&mut std::io::stderr(), "foo: {:?}", bar).unwrap();
@ -27,7 +27,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::io::Write;
/// # let bar = "furchtbar";
/// eprintln!("foo: {:?}", bar);

4
clippy_lints/src/extra_unused_type_parameters.rs
View File

@ -23,13 +23,13 @@ declare_clippy_lint! {
/// requires using a turbofish, which serves no purpose but to satisfy the compiler.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn unused_ty<T>(x: u8) {
/// // ..
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn no_unused_ty(x: u8) {
/// // ..
/// }

4
clippy_lints/src/fallible_impl_from.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// `TryFrom` should be used if there's a possibility of failure.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo(i32);
///
/// impl From<String> for Foo {
@ -28,7 +28,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// struct Foo(i32);
///
/// impl TryFrom<String> for Foo {

8
clippy_lints/src/float_literal.rs
View File

@ -18,13 +18,13 @@ declare_clippy_lint! {
/// Rust will truncate the literal silently.
///
/// ### Example
/// ```rust
/// ```no_run
/// let v: f32 = 0.123_456_789_9;
/// println!("{}", v); // 0.123_456_789
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let v: f64 = 0.123_456_789_9;
/// println!("{}", v); // 0.123_456_789_9
/// ```
@ -44,12 +44,12 @@ declare_clippy_lint! {
/// conversion to a float.
///
/// ### Example
/// ```rust
/// ```no_run
/// let _: f32 = 16_777_217.0; // 16_777_216.0
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let _: f32 = 16_777_216.0;
/// let _: f64 = 16_777_217.0;
/// ```

8
clippy_lints/src/floating_point_arithmetic.rs
View File

@ -27,7 +27,7 @@ declare_clippy_lint! {
/// Negatively impacts accuracy.
///
/// ### Example
/// ```rust
/// ```no_run
/// let a = 3f32;
/// let _ = a.powf(1.0 / 3.0);
/// let _ = (1.0 + a).ln();
@ -35,7 +35,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let a = 3f32;
/// let _ = a.cbrt();
/// let _ = a.ln_1p();
@ -57,7 +57,7 @@ declare_clippy_lint! {
/// Negatively impacts accuracy and performance.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::f32::consts::E;
///
/// let a = 3f32;
@ -83,7 +83,7 @@ declare_clippy_lint! {
///
/// is better expressed as
///
/// ```rust
/// ```no_run
/// use std::f32::consts::E;
///
/// let a = 3f32;

4
clippy_lints/src/format.rs
View File

@ -23,13 +23,13 @@ declare_clippy_lint! {
/// if `foo: &str`.
///
/// ### Examples
/// ```rust
/// ```no_run
/// let foo = "foo";
/// format!("{}", foo);
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let foo = "foo";
/// foo.to_owned();
/// ```

20
clippy_lints/src/format_args.rs
View File

@ -35,12 +35,12 @@ declare_clippy_lint! {
/// The recommended code is both shorter and avoids a temporary allocation.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::panic::Location;
/// println!("error: {}", format!("something failed at {}", Location::caller()));
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::panic::Location;
/// println!("error: something failed at {}", Location::caller());
/// ```
@ -61,12 +61,12 @@ declare_clippy_lint! {
/// unnecessary.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::panic::Location;
/// println!("error: something failed at {}", Location::caller().to_string());
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::panic::Location;
/// println!("error: something failed at {}", Location::caller());
/// ```
@ -87,7 +87,7 @@ declare_clippy_lint! {
/// The inlined syntax, where allowed, is simpler.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let var = 42;
/// # let width = 1;
/// # let prec = 2;
@ -98,7 +98,7 @@ declare_clippy_lint! {
/// format!("{:.*}", prec, var);
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let var = 42;
/// # let width = 1;
/// # let prec = 2;
@ -111,12 +111,12 @@ declare_clippy_lint! {
///
/// If allow-mixed-uninlined-format-args is set to false in clippy.toml,
/// the following code will also trigger the lint:
/// ```rust
/// ```no_run
/// # let var = 42;
/// format!("{} {}", var, 1+2);
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let var = 42;
/// format!("{var} {}", 1+2);
/// ```
@ -141,13 +141,13 @@ declare_clippy_lint! {
/// an expected formatting operation such as adding padding isn't happening.
///
/// ### Example
/// ```rust
/// ```no_run
/// println!("{:.}", 1.0);
///
/// println!("not padded: {:5}", format_args!("..."));
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// println!("{}", 1.0);
///
/// println!("not padded: {}", format_args!("..."));

8
clippy_lints/src/format_impl.rs
View File

@ -21,7 +21,7 @@ declare_clippy_lint! {
///
/// ### Example
///
/// ```rust
/// ```no_run
/// use std::fmt;
///
/// struct Structure(i32);
@ -33,7 +33,7 @@ declare_clippy_lint! {
///
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::fmt;
///
/// struct Structure(i32);
@ -59,7 +59,7 @@ declare_clippy_lint! {
/// should write to the `Formatter`, not stdout/stderr.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::fmt::{Display, Error, Formatter};
///
/// struct S;
@ -72,7 +72,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::fmt::{Display, Error, Formatter};
///
/// struct S;

4
clippy_lints/src/format_push_string.rs
View File

@ -21,13 +21,13 @@ declare_clippy_lint! {
/// While using `write!` in the suggested way should never fail, this isn't necessarily clear to the programmer.
///
/// ### Example
/// ```rust
/// ```no_run
/// let mut s = String::new();
/// s += &format!("0x{:X}", 1024);
/// s.push_str(&format!("0x{:X}", 1024));
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::fmt::Write as _; // import without risk of name clashing
///
/// let mut s = String::new();

4
clippy_lints/src/formatting.rs
View File

@ -37,7 +37,7 @@ declare_clippy_lint! {
/// This is either a typo in the binary operator or confusing.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let foo = true;
/// # let bar = false;
/// // &&! looks like a different operator
@ -45,7 +45,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let foo = true;
/// # let bar = false;
/// if foo && !bar {}

4
clippy_lints/src/four_forward_slashes.rs
View File

@ -14,7 +14,7 @@ declare_clippy_lint! {
/// comment.
///
/// ### Example
/// ```rust
/// ```no_run
/// //// My amazing data structure
/// pub struct Foo {
/// // ...
@ -22,7 +22,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// /// My amazing data structure
/// pub struct Foo {
/// // ...

4
clippy_lints/src/from_over_into.rs
View File

@ -24,7 +24,7 @@ declare_clippy_lint! {
/// According the std docs implementing `From<..>` is preferred since it gives you `Into<..>` for free where the reverse isn't true.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct StringWrapper(String);
///
/// impl Into<StringWrapper> for String {
@ -34,7 +34,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct StringWrapper(String);
///
/// impl From<String> for StringWrapper {

4
clippy_lints/src/from_raw_with_void_ptr.rs
View File

@ -18,13 +18,13 @@ declare_clippy_lint! {
/// For this to be safe, `c_void` would need to have the same memory layout as the original type, which is often not the case.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::ffi::c_void;
/// let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
/// let _ = unsafe { Box::from_raw(ptr) };
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::ffi::c_void;
/// # let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
/// let _ = unsafe { Box::from_raw(ptr as *mut usize) };

24
clippy_lints/src/functions/mod.rs
View File

@ -23,7 +23,7 @@ declare_clippy_lint! {
/// grouping some parameters into a new type.
///
/// ### Example
/// ```rust
/// ```no_run
/// # struct Color;
/// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) {
/// // ..
@ -46,7 +46,7 @@ declare_clippy_lint! {
/// multiple functions.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn im_too_long() {
/// println!("");
/// // ... 100 more LoC
@ -129,7 +129,7 @@ declare_clippy_lint! {
/// a remnant of a refactoring that removed the return type.
///
/// ### Examples
/// ```rust
/// ```no_run
/// #[must_use]
/// fn useless() { }
/// ```
@ -151,7 +151,7 @@ declare_clippy_lint! {
/// attribute to improve the lint message.
///
/// ### Examples
/// ```rust
/// ```no_run
/// #[must_use]
/// fn double_must_use() -> Result<(), ()> {
/// unimplemented!();
@ -183,7 +183,7 @@ declare_clippy_lint! {
/// `#[must_use]`.
///
/// ### Examples
/// ```rust
/// ```no_run
/// // this could be annotated with `#[must_use]`.
/// pub fn id<T>(t: T) -> T { t }
/// ```
@ -211,7 +211,7 @@ declare_clippy_lint! {
/// instead.
///
/// ### Examples
/// ```rust
/// ```no_run
/// pub fn read_u8() -> Result<u8, ()> { Err(()) }
/// ```
/// should become
@ -262,7 +262,7 @@ declare_clippy_lint! {
/// The size determined by Clippy is platform-dependent.
///
/// ### Examples
/// ```rust
/// ```no_run
/// pub enum ParseError {
/// UnparsedBytes([u8; 512]),
/// UnexpectedEof,
@ -274,7 +274,7 @@ declare_clippy_lint! {
/// }
/// ```
/// should be
/// ```
/// ```no_run
/// pub enum ParseError {
/// UnparsedBytes(Box<[u8; 512]>),
/// UnexpectedEof,
@ -301,7 +301,7 @@ declare_clippy_lint! {
///
/// ### Example
/// ```rust
/// ```no_run
/// struct A {
/// a: String,
/// b: String,
@ -315,7 +315,7 @@ declare_clippy_lint! {
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct A {
/// a: String,
/// b: String,
@ -340,14 +340,14 @@ declare_clippy_lint! {
/// Turbofish syntax (`::<>`) cannot be used when `impl Trait` is being used, making `impl Trait` less powerful. Readability may also be a factor.
///
/// ### Example
/// ```rust
/// ```no_run
/// trait MyTrait {}
/// fn foo(a: impl MyTrait) {
/// // [...]
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// trait MyTrait {}
/// fn foo<T: MyTrait>(a: T) {
/// // [...]

4
clippy_lints/src/future_not_send.rs
View File

@ -34,11 +34,11 @@ declare_clippy_lint! {
/// produced.
///
/// ### Example
/// ```rust
/// ```no_run
/// async fn not_send(bytes: std::rc::Rc<[u8]>) {}
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// async fn is_send(bytes: std::sync::Arc<[u8]>) {}
/// ```
#[clippy::version = "1.44.0"]

4
clippy_lints/src/if_not_else.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// Negations reduce the readability of statements.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let v: Vec<usize> = vec![];
/// # fn a() {}
/// # fn b() {}
@ -30,7 +30,7 @@ declare_clippy_lint! {
///
/// Could be written:
///
/// ```rust
/// ```no_run
/// # let v: Vec<usize> = vec![];
/// # fn a() {}
/// # fn b() {}

4
clippy_lints/src/if_then_some_else_none.rs
View File

@ -21,7 +21,7 @@ declare_clippy_lint! {
/// in comparison to `bool::then`.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let v = vec![0];
/// let a = if v.is_empty() {
/// println!("true!");
@ -33,7 +33,7 @@ declare_clippy_lint! {
///
/// Could be written:
///
/// ```rust
/// ```no_run
/// # let v = vec![0];
/// let a = v.is_empty().then(|| {
/// println!("true!");

4
clippy_lints/src/ignored_unit_patterns.rs
View File

@ -15,14 +15,14 @@ declare_clippy_lint! {
/// would detect a type change that `_` would ignore.
///
/// ### Example
/// ```rust
/// ```no_run
/// match std::fs::create_dir("tmp-work-dir") {
/// Ok(_) => println!("Working directory created"),
/// Err(s) => eprintln!("Could not create directory: {s}"),
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// match std::fs::create_dir("tmp-work-dir") {
/// Ok(()) => println!("Working directory created"),
/// Err(s) => eprintln!("Could not create directory: {s}"),

4
clippy_lints/src/implicit_hasher.rs
View File

@ -35,7 +35,7 @@ declare_clippy_lint! {
/// pieces of code, possibly including external crates.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::collections::HashMap;
/// # use std::hash::{Hash, BuildHasher};
/// # trait Serialize {};
@ -44,7 +44,7 @@ declare_clippy_lint! {
/// pub fn foo(map: &mut HashMap<i32, i32>) { }
/// ```
/// could be rewritten as
/// ```rust
/// ```no_run
/// # use std::collections::HashMap;
/// # use std::hash::{Hash, BuildHasher};
/// # trait Serialize {};

4
clippy_lints/src/implicit_return.rs
View File

@ -24,13 +24,13 @@ declare_clippy_lint! {
/// corresponding statements.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn foo(x: usize) -> usize {
/// x
/// }
/// ```
/// add return
/// ```rust
/// ```no_run
/// fn foo(x: usize) -> usize {
/// return x;
/// }

4
clippy_lints/src/implicit_saturating_add.rs
View File

@ -18,7 +18,7 @@ declare_clippy_lint! {
/// The built-in function is more readable and may be faster.
///
/// ### Example
/// ```rust
/// ```no_run
///let mut u:u32 = 7000;
///
/// if u != u32::MAX {
@ -26,7 +26,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
///let mut u:u32 = 7000;
///
/// u = u.saturating_add(1);

4
clippy_lints/src/implicit_saturating_sub.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// Simplicity and readability. Instead we can easily use an builtin function.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let end: u32 = 10;
/// # let start: u32 = 5;
/// let mut i: u32 = end - start;
@ -26,7 +26,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let end: u32 = 10;
/// # let start: u32 = 5;
/// let mut i: u32 = end - start;

4
clippy_lints/src/implied_bounds_in_impls.rs
View File

@ -29,7 +29,7 @@ declare_clippy_lint! {
/// (e.g. `trait A {} trait B: A {} trait C: B {}`, then having an `fn() -> impl A + C`)
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::ops::{Deref,DerefMut};
/// fn f() -> impl Deref<Target = i32> + DerefMut<Target = i32> {
/// // ^^^^^^^^^^^^^^^^^^^ unnecessary bound, already implied by the `DerefMut` trait bound
@ -37,7 +37,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::ops::{Deref,DerefMut};
/// fn f() -> impl DerefMut<Target = i32> {
/// Box::new(123)

6
clippy_lints/src/inconsistent_struct_constructor.rs
View File

@ -19,7 +19,7 @@ declare_clippy_lint! {
/// Since the order of fields in a constructor doesn't affect the
/// resulted instance as the below example indicates,
///
/// ```rust
/// ```no_run
/// #[derive(Debug, PartialEq, Eq)]
/// struct Foo {
/// x: i32,
@ -35,7 +35,7 @@ declare_clippy_lint! {
/// inconsistent order can be confusing and decreases readability and consistency.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Foo {
/// x: i32,
/// y: i32,
@ -47,7 +47,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # struct Foo {
/// # x: i32,
/// # y: i32,

4
clippy_lints/src/index_refutable_slice.rs
View File

@ -31,7 +31,7 @@ declare_clippy_lint! {
/// patterns.
///
/// ### Example
/// ```rust
/// ```no_run
/// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
///
/// if let Some(slice) = slice {
@ -39,7 +39,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let slice: Option<&[u32]> = Some(&[1, 2, 3]);
///
/// if let Some(&[first, ..]) = slice {

4
clippy_lints/src/indexing_slicing.rs
View File

@ -26,7 +26,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let x = [1, 2, 3, 4];
/// // Index within bounds
///
@ -65,7 +65,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # #![allow(unused)]
///
/// # let x = vec![0; 5];

2
clippy_lints/src/infinite_iter.rs
View File

@ -39,7 +39,7 @@ declare_clippy_lint! {
/// this lint is not clever enough to analyze it.
///
/// ### Example
/// ```rust
/// ```no_run
/// let infinite_iter = 0..;
/// # #[allow(unused)]
/// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));

4
clippy_lints/src/inherent_impl.rs
View File

@ -18,7 +18,7 @@ declare_clippy_lint! {
/// Splitting the implementation of a type makes the code harder to navigate.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct X;
/// impl X {
/// fn one() {}
@ -30,7 +30,7 @@ declare_clippy_lint! {
///
/// Could be written:
///
/// ```rust
/// ```no_run
/// struct X;
/// impl X {
/// fn one() {}

8
clippy_lints/src/inherent_to_string.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// This method is also implicitly defined if a type implements the `Display` trait. As the functionality of `Display` is much more versatile, it should be preferred.
///
/// ### Example
/// ```rust
/// ```no_run
/// pub struct A;
///
/// impl A {
@ -26,7 +26,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// use std::fmt;
///
/// pub struct A;
@ -51,7 +51,7 @@ declare_clippy_lint! {
/// This method is also implicitly defined if a type implements the `Display` trait. The less versatile inherent method will then shadow the implementation introduced by `Display`.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::fmt;
///
/// pub struct A;
@ -70,7 +70,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// use std::fmt;
///
/// pub struct A;

2
clippy_lints/src/init_numbered_fields.rs
View File

@ -20,7 +20,7 @@ declare_clippy_lint! {
/// benefit as opposed to tuple initializers
///
/// ### Example
/// ```rust
/// ```no_run
/// struct TupleStruct(u8, u16);
///
/// let _ = TupleStruct {

2
clippy_lints/src/inline_fn_without_body.rs
View File

@ -18,7 +18,7 @@ declare_clippy_lint! {
/// The inline attribute is ignored for trait methods without bodies.
///
/// ### Example
/// ```rust
/// ```no_run
/// trait Animal {
/// #[inline]
/// fn name(&self) -> &'static str;

8
clippy_lints/src/instant_subtraction.rs
View File

@ -21,13 +21,13 @@ declare_clippy_lint! {
/// `prev_instant.elapsed()` also more clearly signals intention.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::time::Instant;
/// let prev_instant = Instant::now();
/// let duration = Instant::now() - prev_instant;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::time::Instant;
/// let prev_instant = Instant::now();
/// let duration = prev_instant.elapsed();
@ -47,13 +47,13 @@ declare_clippy_lint! {
/// unintentional panics.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::time::{Instant, Duration};
/// let time_passed = Instant::now() - Duration::from_secs(5);
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::time::{Instant, Duration};
/// let time_passed = Instant::now().checked_sub(Duration::from_secs(5));
/// ```

4
clippy_lints/src/int_plus_one.rs
View File

@ -16,14 +16,14 @@ declare_clippy_lint! {
/// Readability -- better to use `> y` instead of `>= y + 1`.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let x = 1;
/// # let y = 1;
/// if x >= y + 1 {}
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let x = 1;
/// # let y = 1;
/// if x > y {}

2
clippy_lints/src/invalid_upcast_comparisons.rs
View File

@ -26,7 +26,7 @@ declare_clippy_lint! {
/// https://github.com/rust-lang/rust-clippy/issues/886
///
/// ### Example
/// ```rust
/// ```no_run
/// let x: u8 = 1;
/// (x as u32) > 300;
/// ```

12
clippy_lints/src/item_name_repetitions.rs
View File

@ -26,7 +26,7 @@ declare_clippy_lint! {
/// (the prefixes are `Foo1` and `Foo2` respectively), as also `Bar螃`, `Bar蟹`
///
/// ### Example
/// ```rust
/// ```no_run
/// enum Cake {
/// BlackForestCake,
/// HummingbirdCake,
@ -34,7 +34,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// enum Cake {
/// BlackForest,
/// Hummingbird,
@ -56,14 +56,14 @@ declare_clippy_lint! {
/// It requires the user to type the module name twice.
///
/// ### Example
/// ```rust
/// ```no_run
/// mod cake {
/// struct BlackForestCake;
/// }
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// mod cake {
/// struct BlackForest;
/// }
@ -119,7 +119,7 @@ declare_clippy_lint! {
/// (the prefixes are `foo1` and `foo2` respectively), as also `bar螃`, `bar蟹`
///
/// ### Example
/// ```rust
/// ```no_run
/// struct Cake {
/// cake_sugar: u8,
/// cake_flour: u8,
@ -127,7 +127,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct Cake {
/// sugar: u8,
/// flour: u8,

4
clippy_lints/src/items_after_statements.rs
View File

@ -16,7 +16,7 @@ declare_clippy_lint! {
/// it's hard to figure out which item is meant in a statement.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn foo() {
/// println!("cake");
/// }
@ -31,7 +31,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn foo() {
/// println!("cake");
/// }

4
clippy_lints/src/items_after_test_module.rs
View File

@ -14,7 +14,7 @@ declare_clippy_lint! {
/// ### Why is this bad?
/// Having items declared after the testing module is confusing and may lead to bad test coverage.
/// ### Example
/// ```rust
/// ```no_run
/// #[cfg(test)]
/// mod tests {
/// // [...]
@ -25,7 +25,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn my_function() {
/// // [...]
/// }

4
clippy_lints/src/iter_not_returning_iterator.rs
View File

@ -15,7 +15,7 @@ declare_clippy_lint! {
/// Methods named `iter` or `iter_mut` conventionally return an `Iterator`.
///
/// ### Example
/// ```rust
/// ```no_run
/// // `String` does not implement `Iterator`
/// struct Data {}
/// impl Data {
@ -25,7 +25,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::str::Chars;
/// struct Data {}
/// impl Data {

8
clippy_lints/src/iter_without_into_iter.rs
View File

@ -20,7 +20,7 @@ declare_clippy_lint! {
/// (`for val in &iter {}`), without having to first call `iter()` or `iter_mut()`.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct MySlice<'a>(&'a [u8]);
/// impl<'a> MySlice<'a> {
/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {
@ -29,7 +29,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct MySlice<'a>(&'a [u8]);
/// impl<'a> MySlice<'a> {
/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {
@ -62,7 +62,7 @@ declare_clippy_lint! {
/// in case of ambiguity with another `IntoIterator` impl.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct MySlice<'a>(&'a [u8]);
/// impl<'a> IntoIterator for &MySlice<'a> {
/// type Item = &'a u8;
@ -73,7 +73,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// struct MySlice<'a>(&'a [u8]);
/// impl<'a> MySlice<'a> {
/// pub fn iter(&self) -> std::slice::Iter<'a, u8> {

4
clippy_lints/src/large_enum_variant.rs
View File

@ -38,7 +38,7 @@ declare_clippy_lint! {
/// this may lead to a false positive.
///
/// ### Example
/// ```rust
/// ```no_run
/// enum Test {
/// A(i32),
/// B([i32; 8000]),
@ -46,7 +46,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// // Possibly better
/// enum Test2 {
/// A(i32),

4
clippy_lints/src/large_futures.rs
View File

@ -16,7 +16,7 @@ declare_clippy_lint! {
/// large size of a `Future` may cause stack overflows.
///
/// ### Example
/// ```rust
/// ```no_run
/// async fn large_future(_x: [u8; 16 * 1024]) {}
///
/// pub async fn trigger() {
@ -26,7 +26,7 @@ declare_clippy_lint! {
///
/// `Box::pin` the big future instead.
///
/// ```rust
/// ```no_run
/// async fn large_future(_x: [u8; 16 * 1024]) {}
///
/// pub async fn trigger() {

4
clippy_lints/src/large_stack_frames.rs
View File

@ -49,7 +49,7 @@ declare_clippy_lint! {
/// ### Example
/// This function creates four 500 KB arrays on the stack. Quite big but just small enough to not trigger `large_stack_arrays`.
/// However, looking at the function as a whole, it's clear that this uses a lot of stack space.
/// ```rust
/// ```no_run
/// struct QuiteLargeType([u8; 500_000]);
/// fn foo() {
/// // ... some function that uses a lot of stack space ...
@ -62,7 +62,7 @@ declare_clippy_lint! {
///
/// Instead of doing this, allocate the arrays on the heap.
/// This currently requires going through a `Vec` first and then converting it to a `Box`:
/// ```rust
/// ```no_run
/// struct NotSoLargeType(Box<[u8]>);
///
/// fn foo() {

10
clippy_lints/src/let_underscore.rs
View File

@ -17,7 +17,7 @@ declare_clippy_lint! {
/// expr
///
/// ### Example
/// ```rust
/// ```no_run
/// fn f() -> Result<u32, u32> {
/// Ok(0)
/// }
@ -69,7 +69,7 @@ declare_clippy_lint! {
/// and ignore the resulting value.
///
/// ### Example
/// ```rust
/// ```no_run
/// async fn foo() -> Result<(), ()> {
/// Ok(())
/// }
@ -77,7 +77,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # async fn context() {
/// async fn foo() -> Result<(), ()> {
/// Ok(())
@ -107,14 +107,14 @@ declare_clippy_lint! {
/// lints.
///
/// ### Example
/// ```rust
/// ```no_run
/// fn foo() -> Result<u32, ()> {
/// Ok(123)
/// }
/// let _ = foo();
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn foo() -> Result<u32, ()> {
/// Ok(123)
/// }

8
clippy_lints/src/lifetimes.rs
View File

@ -38,7 +38,7 @@ declare_clippy_lint! {
/// are mentioned due to potential false positives.
///
/// ### Example
/// ```rust
/// ```no_run
/// // Unnecessary lifetime annotations
/// fn in_and_out<'a>(x: &'a u8, y: u8) -> &'a u8 {
/// x
@ -46,7 +46,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn elided(x: &u8, y: u8) -> &u8 {
/// x
/// }
@ -69,7 +69,7 @@ declare_clippy_lint! {
/// them leads to more readable code.
///
/// ### Example
/// ```rust
/// ```no_run
/// // unnecessary lifetimes
/// fn unused_lifetime<'a>(x: u8) {
/// // ..
@ -77,7 +77,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// fn no_lifetime(x: u8) {
/// // ...
/// }

4
clippy_lints/src/lines_filter_map_ok.rs
View File

@ -34,7 +34,7 @@ declare_clippy_lint! {
/// successful results, using `map_while()` would stop at the first error.
///
/// ### Example
/// ```rust
/// ```no_run
/// # use std::{fs::File, io::{self, BufRead, BufReader}};
/// # let _ = || -> io::Result<()> {
/// let mut lines = BufReader::new(File::open("some-path")?).lines().filter_map(Result::ok);
@ -43,7 +43,7 @@ declare_clippy_lint! {
/// # Ok(()) };
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # use std::{fs::File, io::{self, BufRead, BufReader}};
/// # let _ = || -> io::Result<()> {
/// let mut lines = BufReader::new(File::open("some-path")?).lines().map_while(Result::ok);

12
clippy_lints/src/literal_representation.rs
View File

@ -23,14 +23,14 @@ declare_clippy_lint! {
/// Reading long numbers is difficult without separators.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let _: u64 =
/// 61864918973511
/// # ;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let _: u64 =
/// 61_864_918_973_511
/// # ;
@ -73,14 +73,14 @@ declare_clippy_lint! {
/// grouped digits.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let _: u64 =
/// 618_64_9189_73_511
/// # ;
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let _: u64 =
/// 61_864_918_973_511
/// # ;
@ -100,7 +100,7 @@ declare_clippy_lint! {
/// Negatively impacts readability.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x: u32 = 0xFFF_FFF;
/// let y: u8 = 0b01_011_101;
/// ```
@ -120,7 +120,7 @@ declare_clippy_lint! {
/// Negatively impacts readability.
///
/// ### Example
/// ```rust
/// ```no_run
/// let x: u64 = 6186491_8973511;
/// ```
#[clippy::version = "pre 1.29.0"]

48
clippy_lints/src/loops/mod.rs
View File

@ -36,7 +36,7 @@ declare_clippy_lint! {
/// It is not as fast as a memcpy.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let src = vec![1];
/// # let mut dst = vec![0; 65];
/// for i in 0..src.len() {
@ -45,7 +45,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let src = vec![1];
/// # let mut dst = vec![0; 65];
/// dst[64..(src.len() + 64)].clone_from_slice(&src[..]);
@ -67,7 +67,7 @@ declare_clippy_lint! {
/// the bounds check that is done when indexing.
///
/// ### Example
/// ```rust
/// ```no_run
/// let vec = vec!['a', 'b', 'c'];
/// for i in 0..vec.len() {
/// println!("{}", vec[i]);
@ -75,7 +75,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let vec = vec!['a', 'b', 'c'];
/// for i in vec {
/// println!("{}", i);
@ -100,7 +100,7 @@ declare_clippy_lint! {
/// types.
///
/// ### Example
/// ```rust
/// ```no_run
/// // with `y` a `Vec` or slice:
/// # let y = vec![1];
/// for x in y.iter() {
@ -109,7 +109,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let y = vec![1];
/// for x in &y {
/// // ..
@ -130,7 +130,7 @@ declare_clippy_lint! {
/// Readability.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let y = vec![1];
/// // with `y` a `Vec` or slice:
/// for x in y.into_iter() {
@ -138,7 +138,7 @@ declare_clippy_lint! {
/// }
/// ```
/// can be rewritten to
/// ```rust
/// ```no_run
/// # let y = vec![1];
/// for x in y {
/// // ..
@ -217,7 +217,7 @@ declare_clippy_lint! {
/// declutters the code and may be faster in some instances.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let v = vec![1];
/// # fn bar(bar: usize, baz: usize) {}
/// let mut i = 0;
@ -228,7 +228,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// # let v = vec![1];
/// # fn bar(bar: usize, baz: usize) {}
/// for (i, item) in v.iter().enumerate() { bar(i, *item); }
@ -339,7 +339,7 @@ declare_clippy_lint! {
/// code.
///
/// ### Example
/// ```rust
/// ```no_run
/// loop {
/// ..;
/// break;
@ -362,7 +362,7 @@ declare_clippy_lint! {
/// False positive when mutation is followed by a `break`, but the `break` is not immediately
/// after the mutation:
///
/// ```rust
/// ```no_run
/// let mut x = 5;
/// for _ in 0..x {
/// x += 1; // x is a range bound that is mutated
@ -374,7 +374,7 @@ declare_clippy_lint! {
/// False positive on nested loops ([#6072](https://github.com/rust-lang/rust-clippy/issues/6072))
///
/// ### Example
/// ```rust
/// ```no_run
/// let mut foo = 42;
/// for i in 0..foo {
/// foo -= 1;
@ -402,7 +402,7 @@ declare_clippy_lint! {
/// in the condition and only `Upvar` `b` gets mutated in the body, the lint will not trigger.
///
/// ### Example
/// ```rust
/// ```no_run
/// let i = 0;
/// while i > 10 {
/// println!("let me loop forever!");
@ -425,7 +425,7 @@ declare_clippy_lint! {
/// have better performance.
///
/// ### Example
/// ```rust
/// ```no_run
/// let item1 = 2;
/// let item2 = 3;
/// let mut vec: Vec<u8> = Vec::new();
@ -438,7 +438,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let item1 = 2;
/// let item2 = 3;
/// let mut vec: Vec<u8> = vec![item1; 20];
@ -459,7 +459,7 @@ declare_clippy_lint! {
/// single element.
///
/// ### Example
/// ```rust
/// ```no_run
/// let item1 = 2;
/// for item in &[item1] {
/// println!("{}", item);
@ -467,7 +467,7 @@ declare_clippy_lint! {
/// ```
///
/// Use instead:
/// ```rust
/// ```no_run
/// let item1 = 2;
/// let item = &item1;
/// println!("{}", item);
@ -489,7 +489,7 @@ declare_clippy_lint! {
///
/// ### Example
///
/// ```rust
/// ```no_run
/// let x = vec![Some(1), Some(2), Some(3)];
/// for n in x {
/// if let Some(n) = n {
@ -498,7 +498,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let x = vec![Some(1), Some(2), Some(3)];
/// for n in x.into_iter().flatten() {
/// println!("{}", n);
@ -555,7 +555,7 @@ declare_clippy_lint! {
///
/// ### Example
///
/// ```rust
/// ```no_run
/// fn example(arr: Vec<i32>) -> Option<i32> {
/// for el in arr {
/// if el == 1 {
@ -566,7 +566,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn example(arr: Vec<i32>) -> Option<i32> {
/// arr.into_iter().find(|&el| el == 1)
/// }
@ -587,7 +587,7 @@ declare_clippy_lint! {
/// pattern matching on the return value of `Vec::pop()`.
///
/// ### Example
/// ```rust
/// ```no_run
/// let mut numbers = vec![1, 2, 3, 4, 5];
/// while !numbers.is_empty() {
/// let number = numbers.pop().unwrap();
@ -595,7 +595,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let mut numbers = vec![1, 2, 3, 4, 5];
/// while let Some(number) = numbers.pop() {
/// // use `number`

4
clippy_lints/src/manual_assert.rs
View File

@ -16,14 +16,14 @@ declare_clippy_lint! {
/// `assert!` is simpler than `if`-then-`panic!`.
///
/// ### Example
/// ```rust
/// ```no_run
/// let sad_people: Vec<&str> = vec![];
/// if !sad_people.is_empty() {
/// panic!("there are sad people: {:?}", sad_people);
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let sad_people: Vec<&str> = vec![];
/// assert!(sad_people.is_empty(), "there are sad people: {:?}", sad_people);
/// ```

4
clippy_lints/src/manual_async_fn.rs
View File

@ -20,13 +20,13 @@ declare_clippy_lint! {
/// It's more idiomatic to use the dedicated syntax.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::future::Future;
///
/// fn foo() -> impl Future<Output = i32> { async { 42 } }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// async fn foo() -> i32 { 42 }
/// ```
#[clippy::version = "1.45.0"]

4
clippy_lints/src/manual_bits.rs
View File

@ -20,11 +20,11 @@ declare_clippy_lint! {
/// Can be written as the shorter `T::BITS`.
///
/// ### Example
/// ```rust
/// ```no_run
/// std::mem::size_of::<usize>() * 8;
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// usize::BITS as usize;
/// ```
#[clippy::version = "1.60.0"]

22
clippy_lints/src/manual_clamp.rs
View File

@ -38,7 +38,7 @@ declare_clippy_lint! {
/// PR](https://github.com/rust-lang/rust-clippy/pull/9484#issuecomment-1278922613).
///
/// ### Examples
/// ```rust
/// ```no_run
/// # let (input, min, max) = (0, -2, 1);
/// if input > max {
/// max
@ -50,13 +50,13 @@ declare_clippy_lint! {
/// # ;
/// ```
///
/// ```rust
/// ```no_run
/// # let (input, min, max) = (0, -2, 1);
/// input.max(min).min(max)
/// # ;
/// ```
///
/// ```rust
/// ```no_run
/// # let (input, min, max) = (0, -2, 1);
/// match input {
/// x if x > max => max,
@ -66,14 +66,14 @@ declare_clippy_lint! {
/// # ;
/// ```
///
/// ```rust
/// ```no_run
/// # let (input, min, max) = (0, -2, 1);
/// let mut x = input;
/// if x < min { x = min; }
/// if x > max { x = max; }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let (input, min, max) = (0, -2, 1);
/// input.clamp(min, max)
/// # ;
@ -207,7 +207,7 @@ impl TypeClampability {
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (input, min, max) = (0, -3, 12);
///
/// if input < min {
@ -256,7 +256,7 @@ fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (input, min_value, max_value) = (0, -3, 12);
///
/// input.max(min_value).min(max_value)
@ -287,7 +287,7 @@ fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> O
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (input, min_value, max_value) = (0, -3, 12);
/// # use std::cmp::{max, min};
/// min(max(input, min_value), max_value)
@ -369,7 +369,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (input, min, max) = (0, -3, 12);
///
/// match input {
@ -428,7 +428,7 @@ fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Opt
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (input, min, max) = (0, -3, 12);
///
/// let mut x = input;
@ -485,7 +485,7 @@ fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) ->
/// Targets patterns like
///
/// ```
/// ```no_run
/// # let (mut input, min, max) = (0, -3, 12);
///
/// if input < min {

8
clippy_lints/src/manual_float_methods.rs
View File

@ -17,12 +17,12 @@ declare_clippy_lint! {
/// The method `is_infinite` is shorter and more readable.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let x = 1.0f32;
/// if x == f32::INFINITY || x == f32::NEG_INFINITY {}
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let x = 1.0f32;
/// if x.is_infinite() {}
/// ```
@ -40,13 +40,13 @@ declare_clippy_lint! {
/// The method `is_finite` is shorter and more readable.
///
/// ### Example
/// ```rust
/// ```no_run
/// # let x = 1.0f32;
/// if x != f32::INFINITY && x != f32::NEG_INFINITY {}
/// if x.abs() < f32::INFINITY {}
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// # let x = 1.0f32;
/// if x.is_finite() {}
/// if x.is_finite() {}

4
clippy_lints/src/manual_hash_one.rs
View File

@ -19,7 +19,7 @@ declare_clippy_lint! {
/// It is more concise to use the `hash_one` method.
///
/// ### Example
/// ```rust
/// ```no_run
/// use std::hash::{BuildHasher, Hash, Hasher};
/// use std::collections::hash_map::RandomState;
///
@ -31,7 +31,7 @@ declare_clippy_lint! {
/// let hash = hasher.finish();
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// use std::hash::BuildHasher;
/// use std::collections::hash_map::RandomState;
///

4
clippy_lints/src/manual_is_ascii_check.rs
View File

@ -23,7 +23,7 @@ declare_clippy_lint! {
/// clear that it's not a specific subset of characters, but all
/// ASCII (lowercase|uppercase|digit|hexdigit) characters.
/// ### Example
/// ```rust
/// ```no_run
/// fn main() {
/// assert!(matches!('x', 'a'..='z'));
/// assert!(matches!(b'X', b'A'..=b'Z'));
@ -37,7 +37,7 @@ declare_clippy_lint! {
/// }
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// fn main() {
/// assert!('x'.is_ascii_lowercase());
/// assert!(b'X'.is_ascii_uppercase());

4
clippy_lints/src/manual_let_else.rs
View File

@ -30,14 +30,14 @@ declare_clippy_lint! {
///
/// ### Example
///
/// ```rust
/// ```no_run
/// # let w = Some(0);
/// let v = if let Some(v) = w { v } else { return };
/// ```
///
/// Could be written:
///
/// ```rust
/// ```no_run
/// # fn main () {
/// # let w = Some(0);
/// let Some(v) = w else { return };

4
clippy_lints/src/manual_main_separator_str.rs
View File

@ -19,11 +19,11 @@ declare_clippy_lint! {
/// an extra memory allocation.
///
/// ### Example
/// ```rust
/// ```no_run
/// let s: &str = &std::path::MAIN_SEPARATOR.to_string();
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// let s: &str = std::path::MAIN_SEPARATOR_STR;
/// ```
#[clippy::version = "1.70.0"]

4
clippy_lints/src/manual_non_exhaustive.rs
View File

@ -22,7 +22,7 @@ declare_clippy_lint! {
/// and allows possible optimizations when applied to enums.
///
/// ### Example
/// ```rust
/// ```no_run
/// struct S {
/// pub a: i32,
/// pub b: i32,
@ -39,7 +39,7 @@ declare_clippy_lint! {
/// struct T(pub i32, pub i32, ());
/// ```
/// Use instead:
/// ```rust
/// ```no_run
/// #[non_exhaustive]
/// struct S {
/// pub a: i32,

Some files were not shown because too many files have changed in this diff Show More