Allowed-by-default lints

These lints are all set to the 'allow' level by default. As such, they won't show up unless you set them to a higher lint level with a flag or attribute.

anonymous-parameters

This lint detects anonymous parameters. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
trait Foo {
    fn foo(usize);
}
}

When set to 'deny', this will produce:

error: use of deprecated anonymous parameter
 --> src/lib.rs:5:11
  |
5 |     fn foo(usize);
  |           ^
  |
  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
  = note: for more information, see issue #41686 <https://github.com/rust-lang/rust/issues/41686>

This syntax is mostly a historical accident, and can be worked around quite easily:


#![allow(unused_variables)]
fn main() {
trait Foo {
    fn foo(_: usize);
}
}

bare-trait-object

This lint suggests using dyn Trait for trait objects. Some example code that triggers this lint:


#![allow(unused_variables)]
#![feature(dyn_trait)]

fn main() {
trait Trait { }

fn takes_trait_object(_: Box<Trait>) {
}
}

When set to 'deny', this will produce:

error: trait objects without an explicit `dyn` are deprecated
 --> src/lib.rs:7:30
  |
7 | fn takes_trait_object(_: Box<Trait>) {
  |                              ^^^^^ help: use `dyn`: `dyn Trait`
  |

To fix it, do as the help message suggests:


#![allow(unused_variables)]
#![feature(dyn_trait)]
#![deny(bare_trait_objects)]

fn main() {
trait Trait { }

fn takes_trait_object(_: Box<dyn Trait>) {
}
}

box-pointers

This lints use of the Box type. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
struct Foo {
    x: Box<isize>,
}
}

When set to 'deny', this will produce:

error: type uses owned (Box type) pointers: std::boxed::Box<isize>
 --> src/lib.rs:6:5
  |
6 |     x: Box<isize> //~ ERROR type uses owned
  |     ^^^^^^^^^^^^^
  |

This lint is mostly historical, and not particularly useful. Box<T> used to be built into the language, and the only way to do heap allocation. Today's Rust can call into other allocators, etc.

elided-lifetime-in-path

This lint detects the use of hidden lifetime parameters. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
struct Foo<'a> {
    x: &'a u32
}

fn foo(x: &Foo) {
}
}

When set to 'deny', this will produce:

error: hidden lifetime parameters are deprecated, try `Foo<'_>`
 --> src/lib.rs:5:12
  |
5 | fn foo(x: &Foo) {
  |            ^^^
  |

Lifetime elision elides this lifetime, but that is being deprecated.

missing-copy-implementations

This lint detects potentially-forgotten implementations of Copy. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
pub struct Foo {
    pub field: i32
}
}

When set to 'deny', this will produce:

error: type could implement `Copy`; consider adding `impl Copy`
 --> src/main.rs:3:1
  |
3 | / pub struct Foo { //~ ERROR type could implement `Copy`; consider adding `impl Copy`
4 | |     pub field: i32
5 | | }
  | |_^
  |

You can fix the lint by deriving Copy.

This lint is set to 'allow' because this code isn't bad; it's common to write newtypes like this specifically so that a Copy type is no longer Copy.

missing-debug-implementations

This lint detects missing implementations of fmt::Debug. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
pub struct Foo;
}

When set to 'deny', this will produce:

error: type does not implement `fmt::Debug`; consider adding `#[derive(Debug)]` or a manual implementation
 --> src/main.rs:3:1
  |
3 | pub struct Foo;
  | ^^^^^^^^^^^^^^^
  |

You can fix the lint by deriving Debug.

missing-docs

This lint detects missing documentation for public items. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
pub fn foo() {}
}

When set to 'deny', this will produce:

error: missing documentation for crate
 --> src/main.rs:1:1
  |
1 | / #![deny(missing_docs)]
2 | |
3 | | pub fn foo() {}
4 | |
5 | | fn main() {}
  | |____________^
  |

error: missing documentation for a function
 --> src/main.rs:3:1
  |
3 | pub fn foo() {}
  | ^^^^^^^^^^^^

To fix the lint, add documentation to all items.

single-use-lifetimes

This lint detects lifetimes that are only used once. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
struct Foo<'x> {
    x: &'x u32
}
}

When set to 'deny', this will produce:

error: lifetime name `'x` only used once
 --> src/main.rs:3:12
  |
3 | struct Foo<'x> {
  |            ^^
  |

trivial-casts

This lint detects trivial casts which could be removed. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
let x: &u32 = &42;
let _ = x as *const u32;
}

When set to 'deny', this will produce:

error: trivial cast: `&u32` as `*const u32`. Cast can be replaced by coercion, this might require type ascription or a temporary variable
 --> src/main.rs:5:13
  |
5 |     let _ = x as *const u32;
  |             ^^^^^^^^^^^^^^^
  |
note: lint level defined here
 --> src/main.rs:1:9
  |
1 | #![deny(trivial_casts)]
  |         ^^^^^^^^^^^^^

trivial-numeric-casts

This lint detects trivial casts of numeric types which could be removed. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
let x = 42i32 as i32;
}

When set to 'deny', this will produce:

error: trivial numeric cast: `i32` as `i32`. Cast can be replaced by coercion, this might require type ascription or a temporary variable
 --> src/main.rs:4:13
  |
4 |     let x = 42i32 as i32;
  |             ^^^^^^^^^^^^
  |

unreachable-pub

This lint triggers for pub items not reachable from the crate root. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
mod foo {
    pub mod bar {
        
    }
}
}

When set to 'deny', this will produce:

error: unreachable `pub` item
 --> src/main.rs:4:5
  |
4 |     pub mod bar {
  |     ---^^^^^^^^
  |     |
  |     help: consider restricting its visibility: `pub(crate)`
  |

unsafe-code

This lint catches usage of unsafe code. Some example code that triggers this lint:

fn main() {
    unsafe {

    }
}

When set to 'deny', this will produce:

error: usage of an `unsafe` block
 --> src/main.rs:4:5
  |
4 | /     unsafe {
5 | |         
6 | |     }
  | |_____^
  |

unstable-features

This lint is deprecated and no longer used.

unused-extern-crates

This lint guards against extern crate items that are never used. Some example code that triggers this lint:

extern crate semver;

When set to 'deny', this will produce:

error: unused extern crate
 --> src/main.rs:3:1
  |
3 | extern crate semver;
  | ^^^^^^^^^^^^^^^^^^^^
  |

unused-import-braces

This lint catches unnecessary braces around an imported item. Some example code that triggers this lint:

use test::{A};

pub mod test {
    pub struct A;
}
fn main() {}

When set to 'deny', this will produce:

error: braces around A is unnecessary
 --> src/main.rs:3:1
  |
3 | use test::{A};
  | ^^^^^^^^^^^^^^
  |

To fix it, use test::A;

unused-qualifications

This lint detects unnecessarily qualified names. Some example code that triggers this lint:

mod foo {
    pub fn bar() {}
}

fn main() {
    use foo::bar;
    foo::bar();
}

When set to 'deny', this will produce:

error: unnecessary qualification
 --> src/main.rs:9:5
  |
9 |     foo::bar();
  |     ^^^^^^^^
  |

You can call bar() directly, without the foo::.

unused-results

This lint checks for the unused result of an expression in a statement. Some example code that triggers this lint:

fn foo<T>() -> T { panic!() }

fn main() {
    foo::<usize>();
}

When set to 'deny', this will produce:

error: unused result
 --> src/main.rs:6:5
  |
6 |     foo::<usize>();
  |     ^^^^^^^^^^^^^^^
  |

variant-size-differences

This lint detects enums with widely varying variant sizes. Some example code that triggers this lint:


#![allow(unused_variables)]
fn main() {
enum En {
    V0(u8),
    VBig([u8; 1024]),
}
}

When set to 'deny', this will produce:

error: enum variant is more than three times larger (1024 bytes) than the next largest
 --> src/main.rs:5:5
  |
5 |     VBig([u8; 1024]),   //~ ERROR variant is more than three times larger
  |     ^^^^^^^^^^^^^^^^
  |