Merge pull request #2579 from rust-lang-nursery/lint_audit_mcve

lint audit: Implementation + move one lint

Author: oli-obk

README.md

@@ -7,7 +7,16 @@
 
 A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
 
-[There are 208 lints included in this crate!](https://rust-lang-nursery.github.io/rust-clippy/master/index.html)
+[There are 248 lints included in this crate!](https://rust-lang-nursery.github.io/rust-clippy/master/index.html)
+
+We have a bunch of lint categories to allow you to choose how much clippy is supposed to ~~annoy~~ help you:
+
+* `clippy` (everything that has no false positives)
+* `clippy_pedantic` (everything)
+* `clippy_style` (code that should be written in a more idiomatic way)
+* `complexity` (code that does something simple but in a complex way)
+* `perf` (code that can be written in a faster way)
+* **`correctness`** (code that is just outright wrong or very very useless)
 
 More to come, please [file an issue](https://github.com/rust-lang-nursery/rust-clippy/issues) if you have ideas!
 

clippy_lints/src/approx_const.rs

@@ -26,9 +26,9 @@ use utils::span_lint;
 /// ```rust
 /// let x = 3.14;
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub APPROX_CONSTANT,
-    Warn,
+    correctness,
     "the approximate of a known float constant (in `std::fXX::consts`)"
 }
 

clippy_lints/src/arithmetic.rs

@@ -15,8 +15,9 @@ use utils::span_lint;
 /// ```rust
 /// a + 1
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub INTEGER_ARITHMETIC,
+    restriction,
     "any integer arithmetic statement"
 }
 
@@ -31,8 +32,9 @@ declare_restriction_lint! {
 /// ```rust
 /// a + 1.0
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub FLOAT_ARITHMETIC,
+    restriction,
     "any floating-point arithmetic statement"
 }
 

clippy_lints/src/array_indexing.rs

@@ -19,9 +19,9 @@ use consts::{constant, Constant};
 /// x[9];
 /// &x[2..9];
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub OUT_OF_BOUNDS_INDEXING,
-    Deny,
+    correctness,
     "out of bounds constant indexing"
 }
 
@@ -39,8 +39,9 @@ declare_lint! {
 /// x[2];
 /// &x[0..2];
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub INDEXING_SLICING,
+    restriction,
     "indexing/slicing usage"
 }
 

clippy_lints/src/assign_ops.rs

@@ -18,8 +18,9 @@ use utils::{higher, sugg};
 /// ```rust
 /// a += 1;
 /// ```
-declare_restriction_lint! {
+declare_clippy_lint! {
     pub ASSIGN_OPS,
+    restriction,
     "any compound assignment operation"
 }
 
@@ -37,9 +38,9 @@ declare_restriction_lint! {
 /// ...
 /// a = a + b;
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub ASSIGN_OP_PATTERN,
-    Warn,
+    style,
     "assigning the result of an operation on a variable to that same variable"
 }
 
@@ -57,9 +58,9 @@ declare_lint! {
 /// ...
 /// a += a + b;
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MISREFACTORED_ASSIGN_OP,
-    Warn,
+    complexity,
     "having a variable on both sides of an assign op"
 }
 

clippy_lints/src/attrs.rs

@@ -29,9 +29,9 @@ use utils::{in_macro, last_line_of_span, match_def_path, opt_def_id, paths, snip
 /// #[inline(always)]
 /// fn not_quite_hot_code(..) { ... }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub INLINE_ALWAYS,
-    Warn,
+    pedantic,
     "use of `#[inline(always)]`"
 }
 
@@ -53,9 +53,9 @@ declare_lint! {
 /// #[allow(unused_import)]
 /// use foo::bar;
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub USELESS_ATTRIBUTE,
-    Warn,
+    correctness,
     "use of lint attributes on `extern crate` items"
 }
 
@@ -72,9 +72,9 @@ declare_lint! {
 /// #[deprecated(since = "forever")]
 /// fn something_else(..) { ... }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub DEPRECATED_SEMVER,
-    Warn,
+    correctness,
     "use of `#[deprecated(since = \"x\")]` where x is not semver"
 }
 
@@ -103,9 +103,9 @@ declare_lint! {
 /// #[inline(always)]
 /// fn this_is_fine_too(..) { ... }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub EMPTY_LINE_AFTER_OUTER_ATTR,
-    Warn,
+    style,
     "empty line after outer attribute"
 }
 

clippy_lints/src/bit_mask.rs

@@ -36,9 +36,9 @@ use consts::{constant, Constant};
 /// ```rust
 /// if (x & 1 == 2) { … }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub BAD_BIT_MASK,
-    Warn,
+    correctness,
     "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
 }
 
@@ -64,9 +64,9 @@ declare_lint! {
 /// ```rust
 /// if (x | 1 > 3) { … }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub INEFFECTIVE_BIT_MASK,
-    Warn,
+    correctness,
     "expressions where a bit mask will be rendered useless by a comparison, e.g. `(x | 1) > 2`"
 }
 
@@ -82,9 +82,9 @@ declare_lint! {
 /// ```rust
 /// x & 0x1111 == 0
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub VERBOSE_BIT_MASK,
-    Warn,
+    style,
     "expressions where a bit mask is less readable than the corresponding method call"
 }
 

clippy_lints/src/blacklisted_name.rs

@@ -14,9 +14,9 @@ use utils::span_lint;
 /// ```rust
 /// let foo = 3.14;
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub BLACKLISTED_NAME,
-    Warn,
+    style,
     "usage of a blacklisted/placeholder name"
 }
 

clippy_lints/src/block_in_if_condition.rs

@@ -15,9 +15,9 @@ use utils::*;
 /// ```rust
 /// if { true } ..
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub BLOCK_IN_IF_CONDITION_EXPR,
-    Warn,
+    style,
     "braces that can be eliminated in conditions, e.g. `if { true } ...`"
 }
 
@@ -34,9 +34,9 @@ declare_lint! {
 /// // or
 /// if somefunc(|x| { x == 47 }) ..
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub BLOCK_IN_IF_CONDITION_STMT,
-    Warn,
+    style,
     "complex blocks in conditions, e.g. `if { let x = true; x } ...`"
 }
 

clippy_lints/src/booleans.rs

@@ -20,9 +20,9 @@ use utils::{in_macro, snippet_opt, span_lint_and_then, SpanlessEq};
 /// if a && true  // should be: if a
 /// if !(a == b)  // should be: if a != b
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub NONMINIMAL_BOOL,
-    Allow,
+    complexity,
     "boolean expressions that can be written more concisely"
 }
 
@@ -38,9 +38,9 @@ declare_lint! {
 /// if a && b || a { ... }
 /// ```
 /// The `b` is unnecessary, the expression is equivalent to `if a`.
-declare_lint! {
+declare_clippy_lint! {
     pub LOGIC_BUG,
-    Warn,
+    correctness,
     "boolean expressions that contain terminals which can be eliminated"
 }
 

clippy_lints/src/bytecount.rs

@@ -20,9 +20,9 @@ use utils::{contains_name, get_pat_name, match_type, paths, single_segment_path,
 /// ```rust
 /// &my_data.filter(|&x| x == 0u8).count() // use bytecount::count instead
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub NAIVE_BYTECOUNT,
-    Warn,
+    perf,
     "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
 }
 

clippy_lints/src/collapsible_if.rs

@@ -62,9 +62,9 @@ use utils::sugg::Sugg;
 ///     …
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub COLLAPSIBLE_IF,
-    Warn,
+    style,
     "`if`s that can be collapsed (e.g. `if x { if y { ... } }` and `else { if x { ... } }`)"
 }
 

clippy_lints/src/const_static_lifetime.rs

@@ -18,9 +18,9 @@ use utils::{in_macro, snippet, span_lint_and_then};
 /// ```rust
 ///  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub CONST_STATIC_LIFETIME,
-    Warn,
+    style,
     "Using explicit `'static` lifetime for constants when elision rules would allow omitting them."
 }
 

clippy_lints/src/copies.rs

@@ -33,9 +33,9 @@ use utils::{get_parent_expr, in_macro, snippet, span_lint_and_then, span_note_an
 ///     …
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub IFS_SAME_COND,
-    Warn,
+    correctness,
     "consecutive `ifs` with the same condition"
 }
 
@@ -54,9 +54,9 @@ declare_lint! {
 ///     42
 /// };
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub IF_SAME_THEN_ELSE,
-    Warn,
+    correctness,
     "if with the same *then* and *else* blocks"
 }
 
@@ -95,9 +95,9 @@ declare_lint! {
 ///     Quz => quz(),
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub MATCH_SAME_ARMS,
-    Warn,
+    pedantic,
     "`match` with identical arm bodies"
 }
 

clippy_lints/src/cyclomatic_complexity.rs

@@ -19,9 +19,9 @@ use utils::{in_macro, is_allowed, match_type, paths, span_help_and_lint, LimitSt
 /// complexity.
 ///
 /// **Example:** No. You'll see it when you get the warning.
-declare_lint! {
+declare_clippy_lint! {
     pub CYCLOMATIC_COMPLEXITY,
-    Warn,
+    complexity,
     "functions that should be split up into multiple functions"
 }
 

clippy_lints/src/derive.rs

@@ -28,9 +28,9 @@ use utils::{is_automatically_derived, is_copy, match_path, span_lint_and_then};
 ///     ...
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub DERIVE_HASH_XOR_EQ,
-    Warn,
+    correctness,
     "deriving `Hash` but implementing `PartialEq` explicitly"
 }
 
@@ -43,7 +43,7 @@ declare_lint! {
 /// nothing more than copy the object, which is what `#[derive(Copy, Clone)]`
 /// gets you.
 ///
-/// **Known problems:** None.
+/// **Known problems:** Bounds of generic types are sometimes wrong: https://github.com/rust-lang/rust/issues/26925
 ///
 /// **Example:**
 /// ```rust
@@ -54,9 +54,9 @@ declare_lint! {
 ///     ..
 /// }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub EXPL_IMPL_CLONE_ON_COPY,
-    Warn,
+    pedantic,
     "implementing `Clone` explicitly on `Copy` types"
 }
 

clippy_lints/src/doc.rs

@@ -25,9 +25,9 @@ use url::Url;
 /// // ^ `foo_bar` and `that::other::module::foo` should be ticked.
 /// fn doit(foo_bar) { .. }
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub DOC_MARKDOWN,
-    Warn,
+    pedantic,
     "presence of `_`, `::` or camel-case outside backticks in documentation"
 }
 

clippy_lints/src/double_comparison.rs

@@ -23,9 +23,9 @@ use utils::{snippet, span_lint_and_sugg, SpanlessEq};
 /// ```rust
 /// x <= y
 /// ```
-declare_lint! {
+declare_clippy_lint! {
     pub DOUBLE_COMPARISONS,
-    Deny,
+    complexity,
     "unnecessary double comparisons that can be simplified"
 }