Rust Lints
- 1: Rust Lints概述
- 2: Lints等级
- 3: Lints分组
- 4: 默认为Allow的Lints
- 5: 默认为Warn的Lints
- 6: 默认为Deny的Lints
1 - Rust Lints概述
在软件中，“Lints”是用于帮助改善源代码的工具。Rust编译器包含许多Lints，并且在编译代码时，它还将运行Lints。这些Lints可能会产生警告，错误或根本不产生任何东西，具体取决于您配置事物的方式。
这是一个小例子：
$ cat main.rs
fn main() {
let x = 5;
}
$ rustc main.rs
warning: unused variable: `x`
--> main.rs:2:9
|
2 | let x = 5;
| ^
|
= note: `#[warn(unused_variables)]` on by default
= note: to avoid this warning, consider using `_x` instead
这是unused_variables Lints，它告诉您已引入了代码中的变量未使用。这不是bug，所以它不是一个错误，但它可能是一个错误，所以你得到一个警告。
2 - Lints等级
在 rustc 中，Lints分为四个级别：
- 允许/allow
- 警告/warn
- 拒绝/deny
- 禁止/forbid
每个Lint都有一个默认级别（在本章后面的Lint列表中有解释），编译器有一个默认警告级别。首先，让我们解释这些级别的含义，然后再讨论配置。
允许/allow
这些Lints存在，但默认情况下不执行任何操作。例如，考虑以下源代码：
pub fn foo() {}
编译此文件不会产生警告：
$ rustc lib.rs --crate-type=lib
$
但是此代码违反了missing_docs lints。
这些Lint主要是通过配置手动打开的，我们将在本节后面讨论。
警告/warn
如果违反lint，“警告/warn” Lints等级将产生警告。例如，此代码违反了unused_variable lint：
pub fn foo() {
let x = 5;
}
这将产生以下警告：
$ rustc lib.rs --crate-type=lib
warning: unused variable: `x`
--> lib.rs:2:9
|
2 | let x = 5;
| ^
|
= note: `#[warn(unused_variables)]` on by default
= note: to avoid this warning, consider using `_x` instead
拒绝/deny
如果违反，“拒绝” lint 将产生错误。例如，此代码导致了 exceeding_bitshifts lint。
fn main() {
100u8 << 10;
}
$ rustc main.rs
error: bitshift exceeds the type's number of bits
--> main.rs:2:13
|
2 | 100u8 << 10;
| ^^^^^^^^^^^
|
= note: `#[deny(exceeding_bitshifts)]` on by default
Lint错误和常规的旧错误有什么区别？Lint可通过级别进行配置，因此，与“允许/allow” Lint相似，默认情况下设置为“拒绝/deny”，则警告/warn 让您允许它们。同样，您可能希望设置一个Lints，warn 默认情况下会产生错误。此Lint等级可为您提供。
禁止/forbid
“禁止/forbid”是一种特殊的Lint级别，比“拒绝/deny”级别高。与“拒绝/deny”相同的是，在此级别的Lint将产生错误，但是与“拒绝/deny”级别不同，“禁止/forbid”级别不能被覆盖为低于错误的任何值。但是，Lint的水平可能仍会受到限制--cap-lints （请参见下文），因此rustc --cap-lints warn将使Lint设置为“禁止/forbid”只是警告。
配置警告级别
还记得我们missing_docs从“允许/allow”Lint级别开始的示例吗？
$ cat lib.rs
pub fn foo() {}
$ rustc lib.rs --crate-type=lib
$
我们可以使用编译器标志以及源代码中的属性来配置该Lint以更高级别运行。
您还可以“限制”Lint，以便编译器可以选择忽略某些Lint级别。我们将在最后讨论。
通过编译器标志
在-A，-W，-D，和-F标志让你把一个或多个Lint设置成允许，警告，拒绝或禁止的等级，就像这样：
$ rustc lib.rs --crate-type=lib -W missing-docs
warning: missing documentation for crate
--> lib.rs:1:1
|
1 | pub fn foo() {}
| ^^^^^^^^^^^^
|
= note: requested on the command line with `-W missing-docs`
warning: missing documentation for a function
--> lib.rs:1:1
|
1 | pub fn foo() {}
| ^^^^^^^^^^^^
$ rustc lib.rs --crate-type=lib -D missing-docs
error: missing documentation for crate
--> lib.rs:1:1
|
1 | pub fn foo() {}
| ^^^^^^^^^^^^
|
= note: requested on the command line with `-D missing-docs`
error: missing documentation for a function
--> lib.rs:1:1
|
1 | pub fn foo() {}
| ^^^^^^^^^^^^
error: aborting due to 2 previous errors
您还可以多次传递每个标志，以更改多个Lint：
$ rustc lib.rs --crate-type=lib -D missing-docs -D unused-variables
当然，您可以将这四个标志混合在一起：
$ rustc lib.rs --crate-type=lib -D missing-docs -A unused-variables
通过属性
还可以使用crate范围的属性修改Lint级别：
$ cat lib.rs
#![warn(missing_docs)]
pub fn foo() {}
$ rustc lib.rs --crate-type=lib
warning: missing documentation for crate
--> lib.rs:1:1
|
1 | / #![warn(missing_docs)]
2 | |
3 | | pub fn foo() {}
| |_______________^
|
note: lint level defined here
--> lib.rs:1:9
|
1 | #![warn(missing_docs)]
| ^^^^^^^^^^^^
warning: missing documentation for a function
--> lib.rs:3:1
|
3 | pub fn foo() {}
| ^^^^^^^^^^^^
所有四种等级，warn，allow，deny，和forbid，都可以这样工作。
您还可以为每个属性传递多个Lint：
#![warn(missing_docs, unused_variables)]
pub fn foo() {}
并一起使用多个属性：
#![warn(missing_docs)]
#![deny(unused_variables)]
pub fn foo() {}
封顶Lint
rustc 支持 --cap-lints LEVEL 的标志来设置“Lint上限” 。这是所有Lint的最高等级。因此，例如，如果我们从上面的“ deny” lint级别获取代码示例：
fn main() {
100u8 << 10;
}
然后我们对其进行编译，并为Lint封顶警告：
$ rustc lib.rs --cap-lints warn
warning: bitshift exceeds the type's number of bits
--> lib.rs:2:5
|
2 | 100u8 << 10;
| ^^^^^^^^^^^
|
= note: `#[warn(exceeding_bitshifts)]` on by default
warning: this expression will panic at run-time
--> lib.rs:2:5
|
2 | 100u8 << 10;
| ^^^^^^^^^^^ attempt to shift left with overflow
现在仅警告，而不是错误。我们可以走得更远，并允许所有Lint：
$ rustc lib.rs --cap-lints allow
$
Cargo大量使用此特性；它会使用 --cap-lints allow 以便在编译依赖项时通过，这样，即使它们有任何警告，也不会污染生成的输出。
3 - Lints分组
备注：翻译自英文原文： https://doc.rust-lang.org/rustc/lints/groups.html
rustc 具有“Lint Group”的概念，您可以通过一个名称切换多个警告。
例如，nonstandard-style lint 一次性设置 non-camel-case-types， non-snake-case以及non-upper-case-globals。所以一下是等效的：
$ rustc -D nonstandard-style
$ rustc -D non-camel-case-types -D non-snake-case -D non-upper-case-globals
以下是每个Lint组及其组成的Lint的列表：
| 组 | 描述 | 棉绒 |
|---|---|---|
| nonstandard-style | 违反标准命名约定 | 非驼峰式，非蛇形，非大写全局 non-camel-case-types, non-snake-case, non-upper-case-globals |
| warnings | 发出警告的所有Lint | 发出警告的所有Lint |
| 2018版 | 在Rust 2018中将变成错误的Lint | tyvar-behind-raw-pointer |
| rust-2018-idioms | 推动您朝Rust 2018的惯例前进的Lint | bare-trait-object, unreachable-pub |
| unused | 检测到已声明但未使用的事物的Lint | unused-imports, unused-variables, unused-assignments, dead-code, unused-mut, unreachable-code, unreachable-patterns, unused-must-use, unused-unsafe, path-statements, unused-attributes, unused-macros, unused-allocation, unused-doc-comment, unused-extern-crates, unused-features, unused-parens |
| future-incompatible | 检测到代码具有未来兼容性问题的Lint | private-in-public, pub-use-of-private-extern-crate, patterns-in-fns-without-body, safe-extern-statics, invalid-type-param-default, legacy-directory-ownership, legacy-imports, legacy-constructor-visibility, missing-fragment-specifier, illegal-floating-point-literal-pattern, anonymous-parameters, parenthesized-params-in-types-and-modules, late-bound-lifetime-arguments, safe-packed-borrows, tyvar-behind-raw-pointer, unstable-name-collision |
此外，还有一个bad-style Lint Group，它是 nonstandard-style 的别名，但已经不推荐使用。
最后，您还可以通过调用来查看上表rustc -W help。这将为您已安装的特定编译器提供确切值。
4 - 默认为Allow的Lints
英文原文地址： https://doc.rust-lang.org/rustc/lints/listing/allowed-by-default.html
默认情况下，这些 lint 都设置为 allow 级别。因此，除非您使用标志或属性将它们设置为更高的 lint 级别，否则它们将不会显示。
anonymous-parameters
此 lint 检测匿名参数。一些触发此 lint 的示例代码：
trait Foo {
fn foo(usize);
}
当设置为’deny’时，这将产生：
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>
这种语法大多是历史原因，可以很容易地解决：
trait Foo {
fn foo(_: usize);
}
bare-trait-object
这个 lint 暗示对 trait 对象，使用dyn Trait。一些触发此 lint 的示例代码：
#![feature(dyn_trait)]
trait Trait { }
fn takes_trait_object(_: Box<Trait>) {
}
当设置为’deny’时，这将产生：
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`
|
要解决此问题，请按照帮助消息的建议执行操作：
#![feature(dyn_trait)]
#![deny(bare_trait_objects)]
trait Trait { }
fn takes_trait_object(_: Box<dyn Trait>) {
}
box-pointers
给 Box 类型使用的 lints。一些触发此 lint 的示例代码：
struct Foo {
x: Box<isize>,
}
当设置为’deny’时，这将产生：
error: type uses owned (Box type) pointers: std::boxed::Box<isize>
--> src/lib.rs:6:5
|
6 | x: Box<isize> //~ ERROR type uses owned
| ^^^^^^^^^^^^^
|
这种 lint 主要是历史性的，并不是特别有用。以前，Box是用于构建语言，以及进行堆分配的唯一方法。今天的 Rust 可以调用其他分配器等。
elided-lifetime-in-path
此 lint 检测隐藏生命周期参数的使用。一些触发此 lint 的示例代码：
struct Foo<'a> {
x: &'a u32
}
fn foo(x: &Foo) {
}
当设置为’deny’时，这将产生：
error: hidden lifetime parameters are deprecated, try `Foo<'_>`
--> src/lib.rs:5:12
|
5 | fn foo(x: &Foo) {
| ^^^
|
生命周期省略规则隐藏这个生命周期，但是这个被弃用了。
missing-copy-implementations
这个 lint 检测到可能被遗忘的Copy实现。一些触发此 lint 的示例代码：
pub struct Foo {
pub field: i32
}
当设置为’deny’时，这将产生：
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 | | }
| |_^
|
您可以通过派生Copy，来修复 lint。
这个 lint 被设置为’allow’，因为这个代码并不坏; 特别是常写一个类似这样的新类型，所以一个Copy类型不再是Copy（it’s common to write newtypes like this specifically so that a Copy type is no longer Copy）。
missing-debug-implementations
此 lint 检测到缺少的fmt::Debug实现。一些触发此 lint 的示例代码：
pub struct Foo;
当设置为’deny’时，这将产生：
error: type does not implement `fmt::Debug`; consider adding #[derive(Debug)] or a manual implementation
--> src/main.rs:3:1
|
3 | pub struct Foo;
| ^^^^^^^^^^^^^^^
|
您可以通过派生Debug来修复 lint。
missing-docs
此 lint 检测到公有项的缺乏文档。一些触发此 lint 的示例代码：
pub fn foo() {}
当设置为’deny’时，这将产生：
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() {}
| ^^^^^^^^^^^^
要修复 lint，请为所有项添加文档。
single-use-lifetime
此 lint 检测仅使用一次的生命周期。一些触发此 lint 的示例代码：
struct Foo<'x> {
x: &'x u32
}
当设置为’deny’时，这将产生：
error: lifetime name `'x` only used once
--> src/main.rs:3:12
|
3 | struct Foo<'x> {
| ^^
|
trivial-casts
这种 lint 可以检测到可以移除的琐碎成本。一些触发此 lint 的示例代码：
let x: &u32 = &42;
let _ = x as *const u32;
当设置为’deny’时，这将产生：
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
此 lint 检测可以删除的数字类型的简单转换。一些触发此 lint 的示例代码：
let x = 42i32 as i32;
当设置为’deny’时，这将产生：
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
无法从crate root到达的pub项会出发这个lint。一些触发此 lint 的示例代码：
mod foo {
pub mod bar {
}
}
当设置为’deny’时，这将产生：
error: unreachable `pub` item
--> src/main.rs:4:5
|
4 | pub mod bar {
| ---^^^^^^^^
| |
| help: consider restricting its visibility: `pub(crate)`
|
unsafe-code
这种 lint 可以使用unsafe码。一些触发此 lint 的示例代码：
fn main() {
unsafe {
}
}
当设置为’deny’时，这将产生：
error: usage of an `unsafe` block
--> src/main.rs:4:5
|
4 | / unsafe {
5 | |
6 | | }
| |_____^
|
unstable-features
此 lint 已弃用，不再使用。
unused-extern-crates
这种 lint 可以检测标记为 extern crate 但是从未使用过的情况。一些触发此 lint 的示例代码：
extern crate semver;
当设置为’deny’时，这将产生：
error: unused extern crate
--> src/main.rs:3:1
|
3 | extern crate semver;
| ^^^^^^^^^^^^^^^^^^^^
|
unused-import-braces
此 lint 捕获导入项目周围，有不必要的括号。一些触发此 lint 的示例代码：
use test::{A};
pub mod test {
pub struct A;
}
当设置为’deny’时，这将产生：
error: braces around A is unnecessary
--> src/main.rs:3:1
|
3 | use test::{A};
| ^^^^^^^^^^^^^^
|
要解决这个问题，use test::A;
unused-qualifications
此 lint 检测到不必要的限定名称。一些触发此 lint 的示例代码：
mod foo {
pub fn bar() {}
}
fn main() {
use foo::bar;
foo::bar();
}
当设置为’deny’时，这将产生：
error: unnecessary qualification
--> src/main.rs:9:5
|
9 | foo::bar();
| ^^^^^^^^
|
你可以直接调用bar()，没有foo::。
unused-results
此 lint 检查语句中表达式的未使用结果。一些触发此 lint 的示例代码：
fn foo<T>() -> T { panic!() }
fn main() {
foo::<usize>();
}
当设置为’deny’时，这将产生：
error: unused result
--> src/main.rs:6:5
|
6 | foo::<usize>();
| ^^^^^^^^^^^^^^^
|
variant-size-differences
此 lint 检测具有各种变量大小的枚举。一些触发此 lint 的示例代码：
enum En {
V0(u8),
VBig([u8; 1024]),
}
当设置为’deny’时，这将产生：
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
| ^^^^^^^^^^^^^^^^
|
5 - 默认为Warn的Lints
英文原文地址： https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html
默认情况下，这些 lint 都设置为“警告”级别。
const-err
该 lint 在进行持续求值时，检测到一个错误的表达。一些触发此 lint 的示例代码：
let b = 200u8 + 200u8;
这将产生：
warning: attempt to add with overflow
--> src/main.rs:2:9
|
2 | let b = 200u8 + 200u8;
| ^^^^^^^^^^^^^
|
dead-code
此 lint 检测未使用的，未导出的项。一些触发此 lint 的示例代码：
fn foo() {}
这将产生：
warning: function is never used: `foo`
--> src/lib.rs:2:1
|
2 | fn foo() {}
| ^^^^^^^^
|
deprecated
此 lint 检测使用已弃用的项目。一些触发此 lint 的示例代码：
#[deprecated]
fn foo() {}
fn bar() {
foo();
}
这将产生：
warning: use of deprecated item 'foo'
--> src/lib.rs:7:5
|
7 | foo();
| ^^^
|
illegal-floating-point-literal-pattern
此 lint 检测模式中使用的浮点数字面量。一些触发此 lint 的示例代码：
let x = 42.0;
match x {
5.0 => {},
_ => {},
}
这将产生：
warning: floating-point literals cannot be used in patterns
--> src/main.rs:4:9
|
4 | 5.0 => {},
| ^^^
|
= note: #[warn(illegal_floating_point_literal_pattern)] on by default
= 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 #41620 <https://github.com/rust-lang/rust/issues/41620>
improper-ctypes
此 lint 检测到外部模块中， libc 类型的正确使用。一些触发此 lint 的示例代码：
extern "C" {
static STATIC: String;
}
这将产生：
warning: found struct without foreign-function-safe representation annotation in foreign module, consider adding a #[repr(C)] attribute to the type
--> src/main.rs:2:20
|
2 | static STATIC: String;
| ^^^^^^
|
late-bound-lifetime-arguments
此 lint 使用后绑定生命周期参数，检测路径片段中的泛型生存周期参数。一些触发此 lint 的示例代码：
struct S;
impl S {
fn late<'a, 'b>(self, _: &'a u8, _: &'b u8) {}
}
fn main() {
S.late::<'static>(&0, &0);
}
这将产生：
warning: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> src/main.rs:8:14
|
4 | fn late<'a, 'b>(self, _: &'a u8, _: &'b u8) {}
| -- the late bound lifetime parameter is introduced here
...
8 | S.late::<'static>(&0, &0);
| ^^^^^^^
|
= note: #[warn(late_bound_lifetime_arguments)] on by default
= 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 #42868 <https://github.com/rust-lang/rust/issues/42868>
non-camel-case-types
此 lint 检测没有驼峰形式名称的类型，变体，trait 和类型参数。一些触发此 lint 的示例代码：
struct s;
这将产生：
warning: type `s` should have a camel case name such as `S`
--> src/main.rs:1:1
|
1 | struct s;
| ^^^^^^^^^
|
non-shorthand-field-patterns
此 lint 检测在一个模式中，使用Struct { x: x }能代替Struct { x }。一些触发此 lint 的示例代码：
struct Point {
x: i32,
y: i32,
}
fn main() {
let p = Point {
x: 5,
y: 5,
};
match p {
Point { x: x, y: y } => (),
}
}
这将产生：
warning: the `x:` in this pattern is redundant
--> src/main.rs:14:17
|
14 | Point { x: x, y: y } => (),
| --^^
| |
| help: remove this
|
warning: the `y:` in this pattern is redundant
--> src/main.rs:14:23
|
14 | Point { x: x, y: y } => (),
| --^^
| |
| help: remove this
non-snake-case
此 lint 检测没有蛇形式名称的变量，方法，函数，生命周期参数和模块。一些触发此 lint 的示例代码：
let X = 5;
这将产生：
warning: variable `X` should have a snake case name such as `x`
--> src/main.rs:2:9
|
2 | let X = 5;
| ^
|
non-upper-case-globals
此 lint 检测不大写的静态常量。一些触发此 lint 的示例代码：
static x: i32 = 5;
这将产生：
warning: static variable `x` should have an upper case name such as `X`
--> src/main.rs:1:1
|
1 | static x: i32 = 5;
| ^^^^^^^^^^^^^^^^^^
|
no-mangle-generic-items
此 lint 检测泛型项必须被修复(mangle)。一些触发此 lint 的示例代码：
#[no_mangle]
fn foo<T>(t: T) {
}
这将产生：
warning: functions generic over types must be mangled
--> src/main.rs:2:1
|
1 | #[no_mangle]
| ------------ help: remove this attribute
2 | / fn foo<T>(t: T) {
3 | |
4 | | }
| |_^
|
path-statements
此 lint 检测路径语句无效。一些触发此 lint 的示例代码：
let x = 42;
x;
这将产生：
warning: path statement with no effect
--> src/main.rs:3:5
|
3 | x;
| ^^
|
patterns-in-fns-without-body
这个 lint 检测到以前的错误，就是没有body的函数模式。一些触发此 lint 的示例代码：
trait Trait {
fn foo(mut arg: u8);
}
这将产生：
warning: patterns aren't allowed in methods without bodies
--> src/main.rs:2:12
|
2 | fn foo(mut arg: u8);
| ^^^^^^^
|
= note: #[warn(patterns_in_fns_without_body)] on by default
= 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 #35203 <https://github.com/rust-lang/rust/issues/35203>
要解决此问题，请删除该模式; 它可以在实现中使用，而无需在定义中使用mut。那是：
trait Trait {
fn foo(arg: u8);
}
impl Trait for i32 {
fn foo(mut arg: u8) {
}
}
plugin-as-library
此 lint 检测，当编译器插件用作非插件包中的普通库。一些触发此 lint 的示例代码：
#![feature(plugin)]
#![plugin(macro_crate_test)]
extern crate macro_crate_test;
private-in-public
此 lint 检测未被旧实现捕获的公有接口中的私有项。一些触发此 lint 的示例代码：
pub trait Trait {
type A;
}
pub struct S;
mod foo {
struct Z;
impl ::Trait for ::S {
type A = Z;
}
}
这将产生：
error[E0446]: private type `foo::Z` in public interface
--> src/main.rs:11:9
|
11 | type A = Z;
| ^^^^^^^^^^^ can't leak private type
private-no-mangle-fns
此 lint 检测标记#[no_mangle]的函数，这也是私有的。鉴于私有函数不公开，并且#[no_mangle]控制公有符号，这种组合是错误的。一些触发此 lint 的示例代码：
#[no_mangle]
fn foo() {}
这将产生：
warning: function is marked #[no_mangle], but not exported
--> src/main.rs:2:1
|
2 | fn foo() {}
| -^^^^^^^^^^
| |
| help: try making it public: `pub`
|
要解决此问题，请将其公有或删除#[no_mangle]。
private-no-mangle-statics
此 lint 检测到标记#[no_mangle]的任何静态是私有的。鉴于私有静态不公开，并且#[no_mangle]控制公共符号，这种组合是错误的。一些触发此 lint 的示例代码：
#[no_mangle]
static X: i32 = 4;
这将产生：
warning: static is marked #[no_mangle], but not exported
--> src/main.rs:2:1
|
2 | static X: i32 = 4;
| -^^^^^^^^^^^^^^^^^
| |
| help: try making it public: `pub`
|
要解决此问题，请将其公开或删除#[no_mangle]。
renamed-and-removed-lints
此 lint 检测已重命名或删除的 lint。一些触发此 lint 的示例代码：
#![deny(raw_pointer_derive)]
这将产生：
warning: lint raw_pointer_derive has been removed: using derive with raw pointers is ok
--> src/main.rs:1:9
|
1 | #![deny(raw_pointer_derive)]
| ^^^^^^^^^^^^^^^^^^
|
要解决此问题，请删除 lint 或使用新名称。
safe-packed-borrows
此 lint 检测借用除 1 之外的压缩对齐结构内部的字段。触发此 lint 的一些示例代码：
#[repr(packed)]
pub struct Unaligned<T>(pub T);
pub struct Foo {
start: u8,
data: Unaligned<u32>,
}
fn main() {
let x = Foo { start: 0, data: Unaligned(1) };
let y = &x.data.0;
}
这将产生：
warning: borrow of packed field requires unsafe function or block (error E0133)
--> src/main.rs:11:13
|
11 | let y = &x.data.0;
| ^^^^^^^^^
|
= note: #[warn(safe_packed_borrows)] on by default
= 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 #46043 <https://github.com/rust-lang/rust/issues/46043>
stable-features
此 lint 检测#[feature]的属性变得稳定了。一些触发此 lint 的示例代码：这将产生：
#![feature(test_accepted_feature)]
要修复，只需删除
warning: this feature has been stable since 1.0.0. Attribute no longer needed
--> src/main.rs:1:12
|
1 | #![feature(test_accepted_feature)]
| ^^^^^^^^^^^^^^^^^^^^^
|
属性，因为它不再需要。#![feature]类型的别名边界
type-alias-bounds
这 lint 检测类型别名的边界。目前未被执行。一些触发此 lint 的示例代码：
type SendVec<T: Send> = Vec<T>;
这将产生：
warning: type alias is never used: `SendVec`
--> src/main.rs:1:1
|
1 | type SendVec<T: Send> = Vec<T>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
tyvar-behind-raw-pointer
此 lint 检测指向一个推断变量的原始指针。一些触发此 lint 的示例代码：
let data = std::ptr::null();
let _ = &data as *const *const ();
if data.is_null() {}
这将产生：
warning: type annotations needed
--> src/main.rs:4:13
|
4 | if data.is_null() {}
| ^^^^^^^
|
= note: #[warn(tyvar_behind_raw_pointer)] on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #46906 <https://github.com/rust-lang/rust/issues/46906>
unconditional-recursion
此 lint 检测在不调用自身的情况下，无法返回的函数。一些触发此 lint 的示例代码：
fn foo() {
foo();
}
这将产生：
warning: function cannot return without recursing
--> src/main.rs:1:1
|
1 | fn foo() {
| ^^^^^^^^ cannot return without recursing
2 | foo();
| ----- recursive call site
|
unions-with-drop-fields
此 lint 检测联合的使用，其包含可能是重要丢弃代码的字段。一些触发此 lint 的示例代码：
#![feature(untagged_unions)]
union U {
s: String,
}
这将产生：
warning: union contains a field with possibly non-trivial drop code, drop code of union fields is ignored when dropping the union
--> src/main.rs:4:5
|
4 | s: String,
| ^^^^^^^^^
|
unknown-lints
此 lint 检测无法识别的 lint 属性。一些触发此 lint 的示例代码：
#[allow(not_a_real_lint)]
这将产生：
warning: unknown lint: `not_a_real_lint`
--> src/main.rs:1:10
|
1 | #![allow(not_a_real_lint)]
| ^^^^^^^^^^^^^^^
|
unreachable-code
此 lint 检测无法访问的代码路径。一些触发此 lint 的示例代码：
panic!("we never go past here!");
let x = 5;
这将产生：
warning: unreachable statement
--> src/main.rs:4:5
|
4 | let x = 5;
| ^^^^^^^^^^
|
unreachable-patterns
此 lint 检测到无法访问的模式。一些触发此 lint 的示例代码：
let x = 5;
match x {
y => (),
5 => (),
}
这将产生：
warning: unreachable pattern
--> src/main.rs:5:5
|
5 | 5 => (),
| ^
|
该y模式永远匹配，所以五个是不可能达到的。记住，匹配武器按顺序匹配，你可能想把它5上面的案例y案件。
此 lint 检测到您使用了标准库计划在将来添加的名称，这意味着将来如果没有其他类型注释，您的代码可能无法编译。请重命名，或立即添加这些注释。
unused-allocation
此 lint 检测可以消除的不必要的内存分配。
unused-assignments
此 lint 检测永远不会读取的内存分配。一些触发此 lint 的示例代码：
let mut x = 5;
x = 6;
这将产生：
warning: value assigned to `x` is never read
--> src/main.rs:4:5
|
4 | x = 6;
| ^
|
unused-attributes
此 lint 检测编译器未使用的属性。一些触发此 lint 的示例代码：
#![feature(custom_attribute)]
#![mutable_doc]
这将产生：
warning: unused attribute
--> src/main.rs:4:1
|
4 | #![mutable_doc]
| ^^^^^^^^^^^^^^^
|
unused-comparisons
此 lint 检测到所涉及的类型限制使得 比较操作 变得无用。一些触发此 lint 的示例代码：
fn foo(x: u8) {
x >= 0;
}
这将产生：
warning: comparison is useless due to type limits
--> src/main.rs:6:5
|
6 | x >= 0;
| ^^^^^^
|
unused-doc-comment
此 lint 检测 rustdoc 未使用的 doc 注释。一些触发此 lint 的示例代码：
/// docs for x
let x = 12;
这将产生：
warning: doc comment not used by rustdoc
--> src/main.rs:2:5
|
2 | /// docs for x
| ^^^^^^^^^^^^^^
|
unused-features
此 lint 检测在 crate-level 的#[feature]指令 中，找到的未使用或未知功能。要解决此问题，只需删除功能标志即可。
unused-imports
此 lint 检测从未使用过的导入。一些触发此 lint 的示例代码：
use std::collections::HashMap;
这将产生：
warning: unused import: `std::collections::HashMap`
--> src/main.rs:1:5
|
1 | use std::collections::HashMap;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
unused-macros
此 lint 检测未使用的宏。一些触发此 lint 的示例代码：
macro_rules! unused {
() => {};
}
fn main() {
}
这将产生：
warning: unused macro definition
--> src/main.rs:1:1
|
1 | / macro_rules! unused {
2 | | () => {};
3 | | }
| |_^
|
unused-must-use
此 lint 检测标记为＃[must_use]的类型的未使用结果。一些触发此 lint 的示例代码：
fn returns_result() -> Result<(), ()> {
Ok(())
}
fn main() {
returns_result();
}
这将产生：
warning: unused `std::result::Result` that must be used
--> src/main.rs:6:5
|
6 | returns_result();
| ^^^^^^^^^^^^^^^^^
|
unused-mut
此 lint 检测不需要可变的 mut 变量。一些触发此 lint 的示例代码：
let mut x = 5;
这将产生：
warning: variable does not need to be mutable
--> src/main.rs:2:9
|
2 | let mut x = 5;
| ----^
| |
| help: remove this `mut`
|
unused-parens
这个Lint检测到if，match，while和return的括号; 这个括号是不需要的。触发此 lint 的示例代码：
if(true) {}
这将产生：
warning: unnecessary parentheses around `if` condition
--> src/main.rs:2:7
|
2 | if(true) {}
| ^^^^^^ help: remove these parentheses
|
unused-unsafe
这个 lint 检测到不必要的使用unsafe块。一些触发此 lint 的示例代码：
unsafe {}
这将产生：
warning: unnecessary `unsafe` block
--> src/main.rs:2:5
|
2 | unsafe {}
| ^^^^^^ unnecessary `unsafe` block
|
unused-variables
此 lint 检测未以任何方式使用的变量。触发此 lint 的示例代码：
let x = 5;
这将产生：
warning: unused variable: `x`
--> src/main.rs:2:9
|
2 | let x = 5;
| ^ help: consider using `_x` instead
|
warnings
这种 lint 有点特别;通过更改其级别，您可以更改每个其他警告，这些警告会对您想要的任何值产生警告：
#![deny(warnings)]
因此，您不会直接在代码中触发此 lint。
while-true
这个 lint 检测到while true { }。一些触发此 lint 的示例代码：
while true {
}
这将产生：
warning: denote infinite loops with `loop { ... }`
--> src/main.rs:2:5
|
2 | while true {
| ^^^^^^^^^^ help: use `loop`
|
6 - 默认为Deny的Lints
英文原文地址： https://doc.rust-lang.org/rustc/lints/listing/deny-by-default.html
默认情况下，这些 lint 都设置为’deny’级别。
exceeding-bitshifts
此 lint 检测到移位超出了类型的位数。一些触发此 lint 的示例代码：
1_i32 << 32;
这将产生：
error: bitshift exceeds the type's number of bits
--> src/main.rs:2:5
|
2 | 1_i32 << 32;
| ^^^^^^^^^^^
|
invalid-type-param-default
此 lint 检测在无效位置中，允许的类型参数默认值错误。一些触发此 lint 的示例代码：
fn foo<T=i32>(t: T) {}
这将产生：
error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions.
--> src/main.rs:4:8
|
4 | fn foo<T=i32>(t: T) {}
| ^
|
= note: #[deny(invalid_type_param_default)] on by default
= 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 #36887 <https://github.com/rust-lang/rust/issues/36887>
legacy-constructor-visibility
RFC 1506修改了一些可见性规则，并改变了 struct 构造函数的可见性。一些触发此 lint 的示例代码：
mod m {
pub struct S(u8);
fn f() {
// this is trying to use S from the 'use' line, but because the `u8` is
// not pub, it is private
::S;
}
}
use m::S;
这将产生：
error: private struct constructors are not usable through re-exports in outer modules
--> src/main.rs:5:9
|
5 | ::S;
| ^^^
|
= note: #[deny(legacy_constructor_visibility)] on by default
= 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 #39207 <https://github.com/rust-lang/rust/issues/39207>
legacy-directory-ownership
发出 legacy_directory_ownership 时发出
- 有一个带有
＃[path]属性的非内联模块（例如#[path = "foo.rs"]mod bar;）， - 模块的文件（上例中的“foo.rs”）是未命名为“mod.rs”，并且
- 模块的文件包含一个
＃[path]属性的非内联模块。
可以通过将父模块重命名为“mod.rs”，并将其移动到其自己的目录（如果合适的话）来修复警告。
当一个未使用的macro_rules!宏定义模式出现时，会发出 missing_fragment_specifier 警告，因其有一个元变量（例如$e）后面没有片段说明符（例如:expr）。
通过删除未使用的macro_rules!宏定义模式，可以始终修复此警告。
mutable-transmutes
这种 lint 抓取&T到&mut T的转化，因为它是未定义的行为。一些触发此 lint 的示例代码：
unsafe {
let y = std::mem::transmute::<&i32, &mut i32>(&5);
}
这将产生：
error: mutating transmuted &mut T from &T may cause undefined behavior, consider instead using an UnsafeCell
--> src/main.rs:3:17
|
3 | let y = std::mem::transmute::<&i32, &mut i32>(&5);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
no-mangle-const-items
这个 lint 检测到任何带#[no_mangle]属性的const项。常量确实没有导出符号，因此，这可能意味着您打算使用static不是const。一些触发此 lint 的示例代码：
#[no_mangle]
const FOO: i32 = 5;
这将产生：
error: const items should never be #[no_mangle]
--> src/main.rs:3:1
|
3 | const FOO: i32 = 5;
| -----^^^^^^^^^^^^^^
| |
| help: try a static value: `pub static`
|
overflowing-literals
此 lint 检测其类型的字面值超出范围。一些触发此 lint 的示例代码：
let x: u8 = 1000;
这将产生：
error: literal out of range for u8
--> src/main.rs:2:17
|
2 | let x: u8 = 1000;
| ^^^^
|
parenthesized-params-in-types-and-modules
此 lint 检测到不正确的括号。一些触发此 lint 的示例代码：
let x = 5 as usize();
这将产生：
error: parenthesized parameters may only be used with a trait
--> src/main.rs:2:21
|
2 | let x = 5 as usize();
| ^^
|
= note: #[deny(parenthesized_params_in_types_and_modules)] on by default
= 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 #42238 <https://github.com/rust-lang/rust/issues/42238>
要修复它，请删除多个()。
pub-use-of-private-extern-crate
此 lint 检测重新导出一个私有extern crate的特定情况;
在旧版本的 Rust 中，允许extern static以安全代码访问，会存在安全问题。这个 lint 现在抓住并否认这种代码。
此 lint 检测到在一个#[crate_type]指示中，发现一个未知箱类型。一些触发此 lint 的示例代码：
#![crate_type="lol"]
这将产生：
error: invalid `crate_type` value
--> src/lib.rs:1:1
|
1 | #![crate_type="lol"]
| ^^^^^^^^^^^^^^^^^^^^
|
incoherent-fundamental-impls
此 lint 检测到错误允许的潜在冲突的 impl。一些触发此 lint 的示例代码：
pub trait Trait1<X> {
type Output;
}
pub trait Trait2<X> {}
pub struct A;
impl<X, T> Trait1<X> for T where T: Trait2<X> {
type Output = ();
}
impl<X> Trait1<Box<X>> for A {
type Output = i32;
}
这将产生：
error: conflicting implementations of trait `Trait1<std::boxed::Box<_>>` for type `A`: (E0119)
--> src/main.rs:13:1
|
9 | impl<X, T> Trait1<X> for T where T: Trait2<X> {
| --------------------------------------------- first implementation here
...
13 | impl<X> Trait1<Box<X>> for A {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `A`
|
= note: #[deny(incoherent_fundamental_impls)] on by default
= 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 #46205 <https://github.com/rust-lang/rust/issues/46205>